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 #include <dali-toolkit/devel-api/controls/video-view/video-view-devel.h>
 482
 483 #include <dali/devel-api/adaptor-framework/native-image-source-devel.h>
 484
 485
 486 // add here SWIG version check
 487
 488 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 489 // disable Swig-dependent warnings
 490
 491 // 'identifier1' has C-linkage specified,
 492 // but returns UDT 'identifier2' which is incompatible with C
 493 #pragma warning(disable: 4190)
 494
 495 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 496 #pragma warning(disable: 4800)
 497
 498 // debug info too long etc etc
 499 #pragma warning(disable: 4786)
 500 #endif
 501
 502
 503 #include <stdexcept>
 504
 505
 506 #include <string>
 507
 508
 509 #include <vector>
 510 #include <algorithm>
 511 #include <stdexcept>
 512
 513
 514 #include <map>
 515 #include <algorithm>
 516 #include <stdexcept>
 517
 518
 519 #include <utility>
 520
 521
 522 typedef float floatp;
 523
 524 SWIGINTERN floatp *new_floatp(){
 525   return new float();
 526 }
 527 SWIGINTERN void delete_floatp(floatp *self){
 528   if (self) delete self;
 529 }
 530 SWIGINTERN void floatp_assign(floatp *self,float value){
 531   *self = value;
 532 }
 533 SWIGINTERN float floatp_value(floatp *self){
 534   return *self;
 535 }
 536 SWIGINTERN float *floatp_cast(floatp *self){
 537   return self;
 538 }
 539 SWIGINTERN floatp *floatp_frompointer(float *t){
 540   return (floatp *) t;
 541 }
 542
 543 typedef int intp;
 544
 545 SWIGINTERN intp *new_intp(){
 546   return new int();
 547 }
 548 SWIGINTERN void delete_intp(intp *self){
 549   if (self) delete self;
 550 }
 551 SWIGINTERN void intp_assign(intp *self,int value){
 552   *self = value;
 553 }
 554 SWIGINTERN int intp_value(intp *self){
 555   return *self;
 556 }
 557 SWIGINTERN int *intp_cast(intp *self){
 558   return self;
 559 }
 560 SWIGINTERN intp *intp_frompointer(int *t){
 561   return (intp *) t;
 562 }
 563
 564 typedef double doublep;
 565
 566 SWIGINTERN doublep *new_doublep(){
 567   return new double();
 568 }
 569 SWIGINTERN void delete_doublep(doublep *self){
 570   if (self) delete self;
 571 }
 572 SWIGINTERN void doublep_assign(doublep *self,double value){
 573   *self = value;
 574 }
 575 SWIGINTERN double doublep_value(doublep *self){
 576   return *self;
 577 }
 578 SWIGINTERN double *doublep_cast(doublep *self){
 579   return self;
 580 }
 581 SWIGINTERN doublep *doublep_frompointer(double *t){
 582   return (doublep *) t;
 583 }
 584
 585 typedef unsigned int uintp;
 586
 587 SWIGINTERN uintp *new_uintp(){
 588   return new unsigned int();
 589 }
 590 SWIGINTERN void delete_uintp(uintp *self){
 591   if (self) delete self;
 592 }
 593 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 594   *self = value;
 595 }
 596 SWIGINTERN unsigned int uintp_value(uintp *self){
 597   return *self;
 598 }
 599 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 600   return self;
 601 }
 602 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 603   return (uintp *) t;
 604 }
 605
 606 typedef unsigned short ushortp;
 607
 608 SWIGINTERN ushortp *new_ushortp(){
 609   return new unsigned short();
 610 }
 611 SWIGINTERN void delete_ushortp(ushortp *self){
 612   if (self) delete self;
 613 }
 614 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 615   *self = value;
 616 }
 617 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 618   return *self;
 619 }
 620 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 621   return self;
 622 }
 623 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 624   return (ushortp *) t;
 625 }
 626
 627 unsigned int int_to_uint(int x) {
 628    return (unsigned int) x;
 629 }
 630
 631
 632 using namespace Dali;
 633 using namespace Dali::Toolkit;
 634
 635 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 636 {
 637   bool result = false;
 638   try
 639   {
 640     // C++ code. DALi uses Handle <-> Body design pattern.
 641     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 642     // Handles in DALi can be converted into a boolean type
 643     // to check if the handle has a valid body attached to it.
 644     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 645     if( *self )
 646     {
 647       result = true;
 648     }
 649     else
 650     {
 651       result = false;
 652     }
 653   }
 654   catch (std::out_of_range& e)
 655   {
 656     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 657     return 0;
 658   }
 659   catch (std::exception& e)
 660   {
 661     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 662     return 0;
 663   }
 664   catch (DaliException e)
 665   {
 666     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 667     return 0;
 668   }
 669   catch (...)
 670   {
 671     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 672     return 0;
 673   }
 674   return result;
 675 }
 676
 677 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 678 {
 679   bool result = false;
 680   try
 681   {
 682     // C++ code. Check if two handles reference the same implemtion
 683     if( *self == rhs)
 684     {
 685       result = true;
 686     }
 687     else
 688     {
 689       result = false;
 690     }
 691   }
 692   catch (std::out_of_range& e)
 693   {
 694     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 695     return 0;
 696   }
 697   catch (std::exception& e)
 698   {
 699     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 700     return 0;
 701   }
 702   catch (DaliException e)
 703   {
 704     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 705     return 0;
 706   }
 707   catch (...)
 708   {
 709     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 710     return 0;
 711   }
 712   return result;
 713 }
 714
 715
 716 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 717      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 718    }
 719 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){
 720      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 721    }
 722 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 723         std::vector< Dali::TouchPoint >* pv = 0;
 724         if (capacity >= 0) {
 725           pv = new std::vector< Dali::TouchPoint >();
 726           pv->reserve(capacity);
 727        } else {
 728           throw std::out_of_range("capacity");
 729        }
 730        return pv;
 731       }
 732 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 733         if (index>=0 && index<(int)self->size())
 734           return (*self)[index];
 735         else
 736           throw std::out_of_range("index");
 737       }
 738 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 739         if (index>=0 && index<(int)self->size())
 740           return (*self)[index];
 741         else
 742           throw std::out_of_range("index");
 743       }
 744 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 745         if (index>=0 && index<(int)self->size())
 746           (*self)[index] = val;
 747         else
 748           throw std::out_of_range("index");
 749       }
 750 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 751         self->insert(self->end(), values.begin(), values.end());
 752       }
 753 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 754         if (index < 0)
 755           throw std::out_of_range("index");
 756         if (count < 0)
 757           throw std::out_of_range("count");
 758         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 759           throw std::invalid_argument("invalid range");
 760         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 761       }
 762 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 763         if (index>=0 && index<(int)self->size()+1)
 764           self->insert(self->begin()+index, x);
 765         else
 766           throw std::out_of_range("index");
 767       }
 768 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 769         if (index>=0 && index<(int)self->size()+1)
 770           self->insert(self->begin()+index, values.begin(), values.end());
 771         else
 772           throw std::out_of_range("index");
 773       }
 774 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 775         if (index>=0 && index<(int)self->size())
 776           self->erase(self->begin() + index);
 777         else
 778           throw std::out_of_range("index");
 779       }
 780 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 781         if (index < 0)
 782           throw std::out_of_range("index");
 783         if (count < 0)
 784           throw std::out_of_range("count");
 785         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 786           throw std::invalid_argument("invalid range");
 787         self->erase(self->begin()+index, self->begin()+index+count);
 788       }
 789 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 790         if (count < 0)
 791           throw std::out_of_range("count");
 792         return new std::vector< Dali::TouchPoint >(count, value);
 793       }
 794 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 795         std::reverse(self->begin(), self->end());
 796       }
 797 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 798         if (index < 0)
 799           throw std::out_of_range("index");
 800         if (count < 0)
 801           throw std::out_of_range("count");
 802         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 803           throw std::invalid_argument("invalid range");
 804         std::reverse(self->begin()+index, self->begin()+index+count);
 805       }
 806 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 807         if (index < 0)
 808           throw std::out_of_range("index");
 809         if (index+values.size() > self->size())
 810           throw std::out_of_range("index");
 811         std::copy(values.begin(), values.end(), self->begin()+index);
 812       }
 813 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 814          return self->Empty();
 815       }
 816 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 817         return self->GetConnectionCount();
 818       }
 819 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 820           self->Connect( func );
 821       }
 822 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 823           self->Disconnect( func );
 824       }
 825 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 826           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 827 /*@SWIG@*/ self->Emit( arg );
 828       }
 829 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 830          return self->Empty();
 831       }
 832 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 833         return self->GetConnectionCount();
 834       }
 835 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 836           self->Connect( func );
 837       }
 838 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 839           self->Disconnect( func );
 840       }
 841 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 842           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 843 /*@SWIG@*/ self->Emit( arg );
 844       }
 845 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 846          return self->Empty();
 847       }
 848 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){
 849         return self->GetConnectionCount();
 850       }
 851 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 *)){
 852           self->Connect( func );
 853       }
 854 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 *)){
 855           self->Disconnect( func );
 856       }
 857 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){
 858           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 859 /*@SWIG@*/ self->Emit( arg );
 860       }
 861 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 862          return self->Empty();
 863       }
 864 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 865         return self->GetConnectionCount();
 866       }
 867 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 868           self->Connect( func );
 869       }
 870 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 871           self->Disconnect( func );
 872       }
 873 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 874           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 875 /*@SWIG@*/ self->Emit( arg );
 876       }
 877 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 878          return self->Empty();
 879       }
 880 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 881         return self->GetConnectionCount();
 882       }
 883 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 884           self->Connect( func );
 885       }
 886 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 887           self->Disconnect( func );
 888       }
 889 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 890           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 891 /*@SWIG@*/ self->Emit( arg );
 892       }
 893 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){
 894          return self->Empty();
 895       }
 896 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){
 897         return self->GetConnectionCount();
 898       }
 899 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 &)){
 900         self->Connect( func );
 901       }
 902 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 &)){
 903         self->Disconnect( func );
 904       }
 905 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){
 906         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 907 /*@SWIG@*/ self->Emit( arg1, arg2 );
 908       }
 909 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){
 910          return self->Empty();
 911       }
 912 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){
 913         return self->GetConnectionCount();
 914       }
 915 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 &)){
 916         self->Connect( func );
 917       }
 918 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 &)){
 919         self->Disconnect( func );
 920       }
 921 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){
 922         return self->Emit( arg1, arg2 );
 923       }
 924 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){
 925          return self->Empty();
 926       }
 927 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){
 928         return self->GetConnectionCount();
 929       }
 930 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 &)){
 931         self->Connect( func );
 932       }
 933 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 &)){
 934         self->Disconnect( func );
 935       }
 936 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){
 937         return self->Emit( arg1, arg2 );
 938       }
 939 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){
 940          return self->Empty();
 941       }
 942 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){
 943         return self->GetConnectionCount();
 944       }
 945 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 &)){
 946         self->Connect( func );
 947       }
 948 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 &)){
 949         self->Disconnect( func );
 950       }
 951 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){
 952         return self->Emit( arg1, arg2 );
 953       }
 954 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 955          return self->Empty();
 956       }
 957 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 958         return self->GetConnectionCount();
 959       }
 960 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 961           self->Connect( func );
 962       }
 963 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 964           self->Disconnect( func );
 965       }
 966 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 967           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 968 /*@SWIG@*/ self->Emit( arg );
 969       }
 970 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 971          return self->Empty();
 972       }
 973 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){
 974         return self->GetConnectionCount();
 975       }
 976 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 &)){
 977           self->Connect( func );
 978       }
 979 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 &)){
 980           self->Disconnect( func );
 981       }
 982 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){
 983           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 984 /*@SWIG@*/ self->Emit( arg );
 985       }
 986 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 987          return self->Empty();
 988       }
 989 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){
 990         return self->GetConnectionCount();
 991       }
 992 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 &)){
 993           self->Connect( func );
 994       }
 995 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 &)){
 996           self->Disconnect( func );
 997       }
 998 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){
 999           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1000 /*@SWIG@*/ self->Emit( arg );
1001       }
1002 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
1003          return self->Empty();
1004       }
1005 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){
1006         return self->GetConnectionCount();
1007       }
1008 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 &)){
1009           self->Connect( func );
1010       }
1011 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 &)){
1012           self->Disconnect( func );
1013       }
1014 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){
1015           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1016 /*@SWIG@*/ self->Emit( arg );
1017       }
1018 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){
1019          return self->Empty();
1020       }
1021 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){
1022         return self->GetConnectionCount();
1023       }
1024 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 &)){
1025         self->Connect( func );
1026       }
1027 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 &)){
1028         self->Disconnect( func );
1029       }
1030 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){
1031         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1032 /*@SWIG@*/ self->Emit( arg1, arg2 );
1033       }
1034 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){
1035          return self->Empty();
1036       }
1037 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){
1038         return self->GetConnectionCount();
1039       }
1040 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 &)){
1041         self->Connect( func );
1042       }
1043 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 &)){
1044         self->Disconnect( func );
1045       }
1046 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){
1047         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1048 /*@SWIG@*/ self->Emit( arg1, arg2 );
1049       }
1050 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){
1051          return self->Empty();
1052       }
1053 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){
1054         return self->GetConnectionCount();
1055       }
1056 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 &)){
1057         self->Connect( func );
1058       }
1059 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 &)){
1060         self->Disconnect( func );
1061       }
1062 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){
1063         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1064 /*@SWIG@*/ self->Emit( arg1, arg2 );
1065       }
1066 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1067          return self->Empty();
1068       }
1069 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1070         return self->GetConnectionCount();
1071       }
1072 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1073           self->Connect( func );
1074       }
1075 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1076           self->Disconnect( func );
1077       }
1078 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1079           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1080 /*@SWIG@*/ self->Emit( arg );
1081       }
1082 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){
1083          return self->Empty();
1084       }
1085 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){
1086         return self->GetConnectionCount();
1087       }
1088 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)){
1089           return self->Connect( func );
1090       }
1091 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)){
1092           self->Disconnect( func );
1093       }
1094 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){
1095           self->Emit( arg1, arg3 );
1096       }
1097 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){
1098          return self->Empty();
1099       }
1100 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){
1101         return self->GetConnectionCount();
1102       }
1103 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)){
1104           return self->Connect( func );
1105       }
1106 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)){
1107           self->Disconnect( func );
1108       }
1109 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){
1110           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1111 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1112       }
1113
1114 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1115          return self->Empty();
1116       }
1117 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1118         return self->GetConnectionCount();
1119       }
1120 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1121           self->Connect( func );
1122       }
1123 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1124           self->Disconnect( func );
1125       }
1126 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1127           return self->Emit();
1128       }
1129
1130 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1131         std::vector< unsigned int >* pv = 0;
1132         if (capacity >= 0) {
1133           pv = new std::vector< unsigned int >();
1134           pv->reserve(capacity);
1135        } else {
1136           throw std::out_of_range("capacity");
1137        }
1138        return pv;
1139       }
1140 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1141         if (index>=0 && index<(int)self->size())
1142           return (*self)[index];
1143         else
1144           throw std::out_of_range("index");
1145       }
1146 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1147         if (index>=0 && index<(int)self->size())
1148           return (*self)[index];
1149         else
1150           throw std::out_of_range("index");
1151       }
1152 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1153         if (index>=0 && index<(int)self->size())
1154           (*self)[index] = val;
1155         else
1156           throw std::out_of_range("index");
1157       }
1158 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1159         self->insert(self->end(), values.begin(), values.end());
1160       }
1161 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1162         if (index < 0)
1163           throw std::out_of_range("index");
1164         if (count < 0)
1165           throw std::out_of_range("count");
1166         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1167           throw std::invalid_argument("invalid range");
1168         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1169       }
1170 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1171         if (index>=0 && index<(int)self->size()+1)
1172           self->insert(self->begin()+index, x);
1173         else
1174           throw std::out_of_range("index");
1175       }
1176 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1177         if (index>=0 && index<(int)self->size()+1)
1178           self->insert(self->begin()+index, values.begin(), values.end());
1179         else
1180           throw std::out_of_range("index");
1181       }
1182 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1183         if (index>=0 && index<(int)self->size())
1184           self->erase(self->begin() + index);
1185         else
1186           throw std::out_of_range("index");
1187       }
1188 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1189         if (index < 0)
1190           throw std::out_of_range("index");
1191         if (count < 0)
1192           throw std::out_of_range("count");
1193         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1194           throw std::invalid_argument("invalid range");
1195         self->erase(self->begin()+index, self->begin()+index+count);
1196       }
1197 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1198         if (count < 0)
1199           throw std::out_of_range("count");
1200         return new std::vector< unsigned int >(count, value);
1201       }
1202 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1203         std::reverse(self->begin(), self->end());
1204       }
1205 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1206         if (index < 0)
1207           throw std::out_of_range("index");
1208         if (count < 0)
1209           throw std::out_of_range("count");
1210         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1211           throw std::invalid_argument("invalid range");
1212         std::reverse(self->begin()+index, self->begin()+index+count);
1213       }
1214 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1215         if (index < 0)
1216           throw std::out_of_range("index");
1217         if (index+values.size() > self->size())
1218           throw std::out_of_range("index");
1219         std::copy(values.begin(), values.end(), self->begin()+index);
1220       }
1221 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1222         return std::find(self->begin(), self->end(), value) != self->end();
1223       }
1224 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1225         int index = -1;
1226         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1227         if (it != self->end())
1228           index = (int)(it - self->begin());
1229         return index;
1230       }
1231 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1232         int index = -1;
1233         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1234         if (rit != self->rend())
1235           index = (int)(self->rend() - 1 - rit);
1236         return index;
1237       }
1238 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1239         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1240         if (it != self->end()) {
1241           self->erase(it);
1242           return true;
1243         }
1244         return false;
1245       }
1246 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){
1247         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1248         if (capacity >= 0) {
1249           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1250           pv->reserve(capacity);
1251        } else {
1252           throw std::out_of_range("capacity");
1253        }
1254        return pv;
1255       }
1256 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){
1257         if (index>=0 && index<(int)self->size())
1258           return (*self)[index];
1259         else
1260           throw std::out_of_range("index");
1261       }
1262 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){
1263         if (index>=0 && index<(int)self->size())
1264           return (*self)[index];
1265         else
1266           throw std::out_of_range("index");
1267       }
1268 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){
1269         if (index>=0 && index<(int)self->size())
1270           (*self)[index] = val;
1271         else
1272           throw std::out_of_range("index");
1273       }
1274 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){
1275         self->insert(self->end(), values.begin(), values.end());
1276       }
1277 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){
1278         if (index < 0)
1279           throw std::out_of_range("index");
1280         if (count < 0)
1281           throw std::out_of_range("count");
1282         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1283           throw std::invalid_argument("invalid range");
1284         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1285       }
1286 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){
1287         if (index>=0 && index<(int)self->size()+1)
1288           self->insert(self->begin()+index, x);
1289         else
1290           throw std::out_of_range("index");
1291       }
1292 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){
1293         if (index>=0 && index<(int)self->size()+1)
1294           self->insert(self->begin()+index, values.begin(), values.end());
1295         else
1296           throw std::out_of_range("index");
1297       }
1298 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){
1299         if (index>=0 && index<(int)self->size())
1300           self->erase(self->begin() + index);
1301         else
1302           throw std::out_of_range("index");
1303       }
1304 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){
1305         if (index < 0)
1306           throw std::out_of_range("index");
1307         if (count < 0)
1308           throw std::out_of_range("count");
1309         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1310           throw std::invalid_argument("invalid range");
1311         self->erase(self->begin()+index, self->begin()+index+count);
1312       }
1313 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){
1314         if (count < 0)
1315           throw std::out_of_range("count");
1316         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1317       }
1318 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){
1319         std::reverse(self->begin(), self->end());
1320       }
1321 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){
1322         if (index < 0)
1323           throw std::out_of_range("index");
1324         if (count < 0)
1325           throw std::out_of_range("count");
1326         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1327           throw std::invalid_argument("invalid range");
1328         std::reverse(self->begin()+index, self->begin()+index+count);
1329       }
1330 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){
1331         if (index < 0)
1332           throw std::out_of_range("index");
1333         if (index+values.size() > self->size())
1334           throw std::out_of_range("index");
1335         std::copy(values.begin(), values.end(), self->begin()+index);
1336       }
1337 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1338         std::vector< Dali::Actor >* pv = 0;
1339         if (capacity >= 0) {
1340           pv = new std::vector< Dali::Actor >();
1341           pv->reserve(capacity);
1342        } else {
1343           throw std::out_of_range("capacity");
1344        }
1345        return pv;
1346       }
1347 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1348         if (index>=0 && index<(int)self->size())
1349           return (*self)[index];
1350         else
1351           throw std::out_of_range("index");
1352       }
1353 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1354         if (index>=0 && index<(int)self->size())
1355           return (*self)[index];
1356         else
1357           throw std::out_of_range("index");
1358       }
1359 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1360         if (index>=0 && index<(int)self->size())
1361           (*self)[index] = val;
1362         else
1363           throw std::out_of_range("index");
1364       }
1365 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1366         self->insert(self->end(), values.begin(), values.end());
1367       }
1368 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1369         if (index < 0)
1370           throw std::out_of_range("index");
1371         if (count < 0)
1372           throw std::out_of_range("count");
1373         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1374           throw std::invalid_argument("invalid range");
1375         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1376       }
1377 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1378         if (index>=0 && index<(int)self->size()+1)
1379           self->insert(self->begin()+index, x);
1380         else
1381           throw std::out_of_range("index");
1382       }
1383 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1384         if (index>=0 && index<(int)self->size()+1)
1385           self->insert(self->begin()+index, values.begin(), values.end());
1386         else
1387           throw std::out_of_range("index");
1388       }
1389 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1390         if (index>=0 && index<(int)self->size())
1391           self->erase(self->begin() + index);
1392         else
1393           throw std::out_of_range("index");
1394       }
1395 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1396         if (index < 0)
1397           throw std::out_of_range("index");
1398         if (count < 0)
1399           throw std::out_of_range("count");
1400         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1401           throw std::invalid_argument("invalid range");
1402         self->erase(self->begin()+index, self->begin()+index+count);
1403       }
1404 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1405         if (count < 0)
1406           throw std::out_of_range("count");
1407         return new std::vector< Dali::Actor >(count, value);
1408       }
1409 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1410         std::reverse(self->begin(), self->end());
1411       }
1412 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1413         if (index < 0)
1414           throw std::out_of_range("index");
1415         if (count < 0)
1416           throw std::out_of_range("count");
1417         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1418           throw std::invalid_argument("invalid range");
1419         std::reverse(self->begin()+index, self->begin()+index+count);
1420       }
1421 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1422         if (index < 0)
1423           throw std::out_of_range("index");
1424         if (index+values.size() > self->size())
1425           throw std::out_of_range("index");
1426         std::copy(values.begin(), values.end(), self->begin()+index);
1427       }
1428 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1429          return self->Empty();
1430       }
1431 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1432         return self->GetConnectionCount();
1433       }
1434 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 &)){
1435           self->Connect( func );
1436       }
1437 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 &)){
1438           self->Disconnect( func );
1439       }
1440 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){
1441           return self->Emit( arg );
1442       }
1443 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){
1444          return self->Empty();
1445       }
1446 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){
1447         return self->GetConnectionCount();
1448       }
1449 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)){
1450         self->Connect( func );
1451       }
1452 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)){
1453         self->Disconnect( func );
1454       }
1455 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){
1456         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1457 /*@SWIG@*/ self->Emit( arg1, arg2 );
1458       }
1459 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1460          return self->Empty();
1461       }
1462 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){
1463         return self->GetConnectionCount();
1464       }
1465 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)){
1466         self->Connect( func );
1467       }
1468 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)){
1469         self->Disconnect( func );
1470       }
1471 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){
1472         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1473 /*@SWIG@*/ self->Emit( arg1, arg2 );
1474       }
1475 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1476          return self->Empty();
1477       }
1478 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1479         return self->GetConnectionCount();
1480       }
1481 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)){
1482         self->Connect( func );
1483       }
1484 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)){
1485         self->Disconnect( func );
1486       }
1487 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){
1488         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1489 /*@SWIG@*/ self->Emit( arg1, arg2 );
1490       }
1491 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){
1492          return self->Empty();
1493       }
1494 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){
1495         return self->GetConnectionCount();
1496       }
1497 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)){
1498         self->Connect( func );
1499       }
1500 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)){
1501         self->Disconnect( func );
1502       }
1503 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){
1504         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1505 /*@SWIG@*/ self->Emit( arg1, arg2 );
1506       }
1507 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1508          return self->Empty();
1509       }
1510 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1511         return self->GetConnectionCount();
1512       }
1513 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)){
1514           self->Connect( func );
1515       }
1516 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)){
1517           self->Disconnect( func );
1518       }
1519 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1520           return self->Emit( arg );
1521       }
1522 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1523          return self->Empty();
1524       }
1525 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1526         return self->GetConnectionCount();
1527       }
1528 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)){
1529           self->Connect( func );
1530       }
1531 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)){
1532           self->Disconnect( func );
1533       }
1534 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1535           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1536 /*@SWIG@*/ self->Emit( arg );
1537       }
1538 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){
1539          return self->Empty();
1540       }
1541 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){
1542         return self->GetConnectionCount();
1543       }
1544 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)){
1545           return self->Connect( func );
1546       }
1547 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)){
1548           self->Disconnect( func );
1549       }
1550 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){
1551           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1552 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1553       }
1554 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1555          return self->Empty();
1556       }
1557 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1558         return self->GetConnectionCount();
1559       }
1560 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)){
1561           self->Connect( func );
1562       }
1563 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)){
1564           self->Disconnect( func );
1565       }
1566 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1567           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1568 /*@SWIG@*/ self->Emit( arg );
1569       }
1570 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){
1571          return self->Empty();
1572       }
1573 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){
1574         return self->GetConnectionCount();
1575       }
1576 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)){
1577           return self->Connect( func );
1578       }
1579 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)){
1580           self->Disconnect( func );
1581       }
1582 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){
1583           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1584 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1585       }
1586 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){
1587          return self->Empty();
1588       }
1589 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){
1590         return self->GetConnectionCount();
1591       }
1592 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 &)){
1593           self->Connect( func );
1594       }
1595 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 &)){
1596           self->Disconnect( func );
1597       }
1598 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){
1599           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1600 /*@SWIG@*/ self->Emit( arg );
1601       }
1602 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1603          return self->Empty();
1604       }
1605 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){
1606         return self->GetConnectionCount();
1607       }
1608 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 &)){
1609           self->Connect( func );
1610       }
1611 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 &)){
1612           self->Disconnect( func );
1613       }
1614 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){
1615           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1616 /*@SWIG@*/ self->Emit( arg );
1617       }
1618
1619
1620 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){
1621          return self->Empty();
1622       }
1623 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){
1624         return self->GetConnectionCount();
1625       }
1626 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 &)){
1627         self->Connect( func );
1628       }
1629 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 &)){
1630         self->Disconnect( func );
1631       }
1632 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){
1633         return self->Emit( arg1, arg2 );
1634       }
1635 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1636          return self->Empty();
1637       }
1638 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1639         return self->GetConnectionCount();
1640       }
1641 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)){
1642           self->Connect( func );
1643       }
1644 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)){
1645           self->Disconnect( func );
1646       }
1647 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1648           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1649 /*@SWIG@*/ self->Emit( arg );
1650       }
1651 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1652          return self->Empty();
1653       }
1654 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1655         return self->GetConnectionCount();
1656       }
1657 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 &)){
1658           self->Connect( func );
1659       }
1660 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 &)){
1661           self->Disconnect( func );
1662       }
1663 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){
1664           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1665 /*@SWIG@*/ self->Emit( arg );
1666       }
1667 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1668          return self->Empty();
1669       }
1670 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){
1671         return self->GetConnectionCount();
1672       }
1673 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)){
1674         self->Connect( func );
1675       }
1676 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)){
1677         self->Disconnect( func );
1678       }
1679 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){
1680         return self->Emit( arg1, arg2 );
1681       }
1682 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1683          return self->Empty();
1684       }
1685 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){
1686         return self->GetConnectionCount();
1687       }
1688 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)){
1689         self->Connect( func );
1690       }
1691 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)){
1692         self->Disconnect( func );
1693       }
1694 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){
1695         return self->Emit( arg1, arg2 );
1696       }
1697
1698 /* ---------------------------------------------------
1699  * C++ director class methods
1700  * --------------------------------------------------- */
1701
1702 #include "dali_wrap.h"
1703
1704 /*
1705  *  Widget director
1706  */
1707 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1708   swig_init_callbacks();
1709 }
1710
1711 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1712 }
1713
1714 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1715   char * jcontentInfo = 0 ;
1716   void * jwindow  ;
1717
1718   if (!swig_callbackOnCreate) {
1719     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1720     return;
1721   } else {
1722     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1723     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1724     swig_callbackOnCreate(jcontentInfo, jwindow);
1725   }
1726 }
1727
1728 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1729   char * jcontentInfo = 0 ;
1730   int jtype  ;
1731
1732   if (!swig_callbackOnTerminate) {
1733     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1734     return;
1735   } else {
1736     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1737     jtype = (int)type;
1738     swig_callbackOnTerminate(jcontentInfo, jtype);
1739   }
1740 }
1741
1742 void SwigDirector_WidgetImpl::OnPause() {
1743   if (!swig_callbackOnPause) {
1744     Dali::Internal::Adaptor::Widget::OnPause();
1745     return;
1746   } else {
1747     swig_callbackOnPause();
1748   }
1749 }
1750
1751 void SwigDirector_WidgetImpl::OnResume() {
1752   if (!swig_callbackOnResume) {
1753     Dali::Internal::Adaptor::Widget::OnResume();
1754     return;
1755   } else {
1756     swig_callbackOnResume();
1757   }
1758 }
1759
1760 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1761   void * jwindow  ;
1762
1763   if (!swig_callbackOnResize) {
1764     Dali::Internal::Adaptor::Widget::OnResize(window);
1765     return;
1766   } else {
1767     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1768     swig_callbackOnResize(jwindow);
1769   }
1770 }
1771
1772 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1773   char * jcontentInfo = 0 ;
1774   int jforce  ;
1775
1776   if (!swig_callbackOnUpdate) {
1777     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1778     return;
1779   } else {
1780     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1781     jforce = force;
1782     swig_callbackOnUpdate(jcontentInfo, jforce);
1783   }
1784 }
1785
1786 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1787   void * jslotObserver = 0 ;
1788   void * jcallback = 0 ;
1789
1790   if (!swig_callbackSignalConnected) {
1791     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1792     return;
1793   } else {
1794     jslotObserver = (void *) slotObserver;
1795     jcallback = (void *) callback;
1796     swig_callbackSignalConnected(jslotObserver, jcallback);
1797   }
1798 }
1799
1800 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1801   void * jslotObserver = 0 ;
1802   void * jcallback = 0 ;
1803
1804   if (!swig_callbackSignalDisconnected) {
1805     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1806     return;
1807   } else {
1808     jslotObserver = (void *) slotObserver;
1809     jcallback = (void *) callback;
1810     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1811   }
1812 }
1813
1814 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) {
1815
1816   swig_callbackOnCreate = callbackOnCreate;
1817   swig_callbackOnTerminate = callbackOnTerminate;
1818   swig_callbackOnPause = callbackOnPause;
1819   swig_callbackOnResume = callbackOnResume;
1820   swig_callbackOnResize = callbackOnResize;
1821   swig_callbackOnUpdate = callbackOnUpdate;
1822   swig_callbackSignalConnected = callbackSignalConnected;
1823   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1824 }
1825
1826 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1827   swig_callbackOnCreate = 0;
1828   swig_callbackOnTerminate = 0;
1829   swig_callbackOnPause = 0;
1830   swig_callbackOnResume = 0;
1831   swig_callbackOnResize = 0;
1832   swig_callbackOnUpdate = 0;
1833   swig_callbackSignalConnected = 0;
1834   swig_callbackSignalDisconnected = 0;
1835 }
1836
1837
1838 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1839   swig_init_callbacks();
1840 }
1841
1842 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1843
1844 }
1845
1846
1847 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1848   int jdepth  ;
1849
1850   if (!swig_callbackOnStageConnection) {
1851     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1852     return;
1853   } else {
1854     jdepth = depth;
1855     swig_callbackOnStageConnection(jdepth);
1856   }
1857 }
1858
1859 void SwigDirector_ViewImpl::OnStageDisconnection() {
1860   if (!swig_callbackOnStageDisconnection) {
1861     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1862     return;
1863   } else {
1864     swig_callbackOnStageDisconnection();
1865   }
1866 }
1867
1868 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1869   void * jchild = 0 ;
1870
1871   if (!swig_callbackOnChildAdd) {
1872     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1873     return;
1874   } else {
1875     jchild = (Dali::Actor *) &child;
1876     swig_callbackOnChildAdd(jchild);
1877   }
1878 }
1879
1880 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1881   void * jchild = 0 ;
1882
1883   if (!swig_callbackOnChildRemove) {
1884     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1885     return;
1886   } else {
1887     jchild = (Dali::Actor *) &child;
1888     swig_callbackOnChildRemove(jchild);
1889   }
1890 }
1891
1892 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1893   int jindex  ;
1894   void * jpropertyValue  ;
1895
1896   if (!swig_callbackOnPropertySet) {
1897     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1898     return;
1899   } else {
1900     jindex = index;
1901     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1902     swig_callbackOnPropertySet(jindex, jpropertyValue);
1903   }
1904 }
1905
1906 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1907   void * jtargetSize = 0 ;
1908
1909   if (!swig_callbackOnSizeSet) {
1910     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1911     return;
1912   } else {
1913     jtargetSize = (Dali::Vector3 *) &targetSize;
1914     swig_callbackOnSizeSet(jtargetSize);
1915   }
1916 }
1917
1918 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1919   void * janimation = 0 ;
1920   void * jtargetSize = 0 ;
1921
1922   if (!swig_callbackOnSizeAnimation) {
1923     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1924     return;
1925   } else {
1926     janimation = (Dali::Animation *) &animation;
1927     jtargetSize = (Dali::Vector3 *) &targetSize;
1928     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1929   }
1930 }
1931
1932 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1933   bool c_result = SwigValueInit< bool >() ;
1934   unsigned int jresult = 0 ;
1935   void * jarg0 = 0 ;
1936
1937   if (!swig_callbackOnTouchEvent) {
1938     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1939   } else {
1940     jarg0 = (Dali::TouchEvent *) &event;
1941     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1942     c_result = jresult ? true : false;
1943   }
1944   return c_result;
1945 }
1946
1947 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1948   bool c_result = SwigValueInit< bool >() ;
1949   unsigned int jresult = 0 ;
1950   void * jarg0 = 0 ;
1951
1952   if (!swig_callbackOnHoverEvent) {
1953     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1954   } else {
1955     jarg0 = (Dali::HoverEvent *) &event;
1956     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1957     c_result = jresult ? true : false;
1958   }
1959   return c_result;
1960 }
1961
1962 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1963   bool c_result = SwigValueInit< bool >() ;
1964   unsigned int jresult = 0 ;
1965   void * jarg0 = 0 ;
1966
1967   if (!swig_callbackOnKeyEvent) {
1968     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1969   } else {
1970     jarg0 = (Dali::KeyEvent *) &event;
1971     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1972     c_result = jresult ? true : false;
1973   }
1974   return c_result;
1975 }
1976
1977 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1978   bool c_result = SwigValueInit< bool >() ;
1979   unsigned int jresult = 0 ;
1980   void * jarg0 = 0 ;
1981
1982   if (!swig_callbackOnWheelEvent) {
1983     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1984   } else {
1985     jarg0 = (Dali::WheelEvent *) &event;
1986     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1987     c_result = jresult ? true : false;
1988   }
1989   return c_result;
1990 }
1991
1992 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1993   void * jsize = 0 ;
1994   void * jcontainer = 0 ;
1995
1996   if (!swig_callbackOnRelayout) {
1997     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1998     return;
1999   } else {
2000     jsize = (Dali::Vector2 *) &size;
2001     jcontainer = (Dali::RelayoutContainer *) &container;
2002     swig_callbackOnRelayout(jsize, jcontainer);
2003   }
2004 }
2005
2006 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
2007   int jpolicy  ;
2008   int jdimension  ;
2009
2010   if (!swig_callbackOnSetResizePolicy) {
2011     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
2012     return;
2013   } else {
2014     jpolicy = (int)policy;
2015     jdimension = (int)dimension;
2016     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
2017   }
2018 }
2019
2020 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2021   Dali::Vector3 c_result ;
2022   void * jresult = 0 ;
2023
2024   if (!swig_callbackGetNaturalSize) {
2025     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2026   } else {
2027     jresult = (void *) swig_callbackGetNaturalSize();
2028     if (!jresult) {
2029       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2030       return c_result;
2031     }
2032     c_result = *(Dali::Vector3 *)jresult;
2033   }
2034   return c_result;
2035 }
2036
2037 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2038   float c_result = SwigValueInit< float >() ;
2039   float jresult = 0 ;
2040   void * jchild = 0 ;
2041   int jdimension  ;
2042
2043   if (!swig_callbackCalculateChildSize) {
2044     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2045   } else {
2046     jchild = (Dali::Actor *) &child;
2047     jdimension = (int)dimension;
2048     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2049     c_result = (float)jresult;
2050   }
2051   return c_result;
2052 }
2053
2054 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2055   float c_result = SwigValueInit< float >() ;
2056   float jresult = 0 ;
2057   float jwidth  ;
2058
2059   if (!swig_callbackGetHeightForWidth) {
2060     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2061   } else {
2062     jwidth = width;
2063     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2064     c_result = (float)jresult;
2065   }
2066   return c_result;
2067 }
2068
2069 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2070   float c_result = SwigValueInit< float >() ;
2071   float jresult = 0 ;
2072   float jheight  ;
2073
2074   if (!swig_callbackGetWidthForHeight) {
2075     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2076   } else {
2077     jheight = height;
2078     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2079     c_result = (float)jresult;
2080   }
2081   return c_result;
2082 }
2083
2084 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2085   bool c_result = SwigValueInit< bool >() ;
2086   unsigned int jresult = 0 ;
2087   int jdimension  ;
2088
2089   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2090     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2091   } else {
2092     jdimension = (int)dimension;
2093     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2094     c_result = jresult ? true : false;
2095   }
2096   return c_result;
2097 }
2098
2099 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2100   int jdimension  ;
2101
2102   if (!swig_callbackOnCalculateRelayoutSize) {
2103     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2104     return;
2105   } else {
2106     jdimension = (int)dimension;
2107     swig_callbackOnCalculateRelayoutSize(jdimension);
2108   }
2109 }
2110
2111 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2112   float jsize  ;
2113   int jdimension  ;
2114
2115   if (!swig_callbackOnLayoutNegotiated) {
2116     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2117     return;
2118   } else {
2119     jsize = size;
2120     jdimension = (int)dimension;
2121     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2122   }
2123 }
2124
2125 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2126   return Dali::CustomActorImpl::GetExtension();
2127 }
2128
2129 void SwigDirector_ViewImpl::OnInitialize() {
2130   if (!swig_callbackOnInitialize) {
2131     Dali::Toolkit::Internal::Control::OnInitialize();
2132     return;
2133   } else {
2134     swig_callbackOnInitialize();
2135   }
2136 }
2137
2138 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2139   void * jchild = 0 ;
2140
2141   if (!swig_callbackOnControlChildAdd) {
2142     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2143     return;
2144   } else {
2145     jchild = (Dali::Actor *) &child;
2146     swig_callbackOnControlChildAdd(jchild);
2147   }
2148 }
2149
2150 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2151   void * jchild = 0 ;
2152
2153   if (!swig_callbackOnControlChildRemove) {
2154     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2155     return;
2156   } else {
2157     jchild = (Dali::Actor *) &child;
2158     swig_callbackOnControlChildRemove(jchild);
2159   }
2160 }
2161
2162 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2163   void * jstyleManager  ;
2164   int jchange  ;
2165
2166   if (!swig_callbackOnStyleChange) {
2167     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2168     return;
2169   } else {
2170     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2171     jchange = (int)change;
2172     swig_callbackOnStyleChange(jstyleManager, jchange);
2173   }
2174 }
2175
2176 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2177   bool c_result = SwigValueInit< bool >() ;
2178   unsigned int jresult = 0 ;
2179
2180   if (!swig_callbackOnAccessibilityActivated) {
2181     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2182   } else {
2183     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2184     c_result = jresult ? true : false;
2185   }
2186   return c_result;
2187 }
2188
2189 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2190   bool c_result = SwigValueInit< bool >() ;
2191   unsigned int jresult = 0 ;
2192   void * jgesture  ;
2193
2194   if (!swig_callbackOnAccessibilityPan) {
2195     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2196   } else {
2197     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2198     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2199     c_result = jresult ? true : false;
2200   }
2201   return c_result;
2202 }
2203
2204 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2205   bool c_result = SwigValueInit< bool >() ;
2206   unsigned int jresult = 0 ;
2207   void * jtouchEvent = 0 ;
2208
2209   if (!swig_callbackOnAccessibilityTouch) {
2210     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2211   } else {
2212     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2213     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2214     c_result = jresult ? true : false;
2215   }
2216   return c_result;
2217 }
2218
2219 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2220   bool c_result = SwigValueInit< bool >() ;
2221   unsigned int jresult = 0 ;
2222   unsigned int jisIncrease  ;
2223
2224   if (!swig_callbackOnAccessibilityValueChange) {
2225     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2226   } else {
2227     jisIncrease = isIncrease;
2228     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2229     c_result = jresult ? true : false;
2230   }
2231   return c_result;
2232 }
2233
2234 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2235   bool c_result = SwigValueInit< bool >() ;
2236   unsigned int jresult = 0 ;
2237
2238   if (!swig_callbackOnAccessibilityZoom) {
2239     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2240   } else {
2241     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2242     c_result = jresult ? true : false;
2243   }
2244   return c_result;
2245 }
2246
2247 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2248   if (!swig_callbackOnKeyInputFocusGained) {
2249     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2250     return;
2251   } else {
2252     swig_callbackOnKeyInputFocusGained();
2253   }
2254 }
2255
2256 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2257   if (!swig_callbackOnKeyInputFocusLost) {
2258     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2259     return;
2260   } else {
2261     swig_callbackOnKeyInputFocusLost();
2262   }
2263 }
2264
2265 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2266   Dali::Actor c_result ;
2267   void * jresult = 0 ;
2268   void * jcurrentFocusedActor  ;
2269   int jdirection  ;
2270   unsigned int jloopEnabled  ;
2271
2272   if (!swig_callbackGetNextKeyboardFocusableActor) {
2273     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2274   } else {
2275     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2276     jdirection = (int)direction;
2277     jloopEnabled = loopEnabled;
2278     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2279     if (!jresult) {
2280       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2281       return c_result;
2282     }
2283     c_result = *(Dali::Actor *)jresult;
2284   }
2285   return c_result;
2286 }
2287
2288 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2289   void * jcommitedFocusableActor  ;
2290
2291   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2292     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2293     return;
2294   } else {
2295     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2296     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2297   }
2298 }
2299
2300 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2301   bool c_result = SwigValueInit< bool >() ;
2302   unsigned int jresult = 0 ;
2303
2304   if (!swig_callbackOnKeyboardEnter) {
2305     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2306   } else {
2307     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2308     c_result = jresult ? true : false;
2309   }
2310   return c_result;
2311 }
2312
2313 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2314   void * jpinch = 0 ;
2315
2316   if (!swig_callbackOnPinch) {
2317     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2318     return;
2319   } else {
2320     jpinch = (Dali::PinchGesture *) &pinch;
2321     swig_callbackOnPinch(jpinch);
2322   }
2323 }
2324
2325 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2326   void * jpan = 0 ;
2327
2328   if (!swig_callbackOnPan) {
2329     Dali::Toolkit::Internal::Control::OnPan(pan);
2330     return;
2331   } else {
2332     jpan = (Dali::PanGesture *) &pan;
2333     swig_callbackOnPan(jpan);
2334   }
2335 }
2336
2337 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2338   void * jtap = 0 ;
2339
2340   if (!swig_callbackOnTap) {
2341     Dali::Toolkit::Internal::Control::OnTap(tap);
2342     return;
2343   } else {
2344     jtap = (Dali::TapGesture *) &tap;
2345     swig_callbackOnTap(jtap);
2346   }
2347 }
2348
2349 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2350   void * jlongPress = 0 ;
2351
2352   if (!swig_callbackOnLongPress) {
2353     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2354     return;
2355   } else {
2356     jlongPress = (Dali::LongPressGesture *) &longPress;
2357     swig_callbackOnLongPress(jlongPress);
2358   }
2359 }
2360
2361 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2362   void * jslotObserver = 0 ;
2363   void * jcallback = 0 ;
2364
2365   if (!swig_callbackSignalConnected) {
2366     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2367     return;
2368   } else {
2369     jslotObserver = (void *) slotObserver;
2370     jcallback = (void *) callback;
2371     swig_callbackSignalConnected(jslotObserver, jcallback);
2372   }
2373 }
2374
2375 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2376   void * jslotObserver = 0 ;
2377   void * jcallback = 0 ;
2378
2379   if (!swig_callbackSignalDisconnected) {
2380     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2381     return;
2382   } else {
2383     jslotObserver = (void *) slotObserver;
2384     jcallback = (void *) callback;
2385     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2386   }
2387 }
2388
2389 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2390   return Dali::Toolkit::Internal::Control::GetControlExtension();
2391 }
2392
2393 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) {
2394   swig_callbackOnStageConnection = callbackOnStageConnection;
2395   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2396   swig_callbackOnChildAdd = callbackOnChildAdd;
2397   swig_callbackOnChildRemove = callbackOnChildRemove;
2398   swig_callbackOnPropertySet = callbackOnPropertySet;
2399   swig_callbackOnSizeSet = callbackOnSizeSet;
2400   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2401   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2402   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2403   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2404   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2405   swig_callbackOnRelayout = callbackOnRelayout;
2406   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2407   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2408   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2409   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2410   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2411   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2412   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2413   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2414   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2415   swig_callbackOnInitialize = callbackOnInitialize;
2416   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2417   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2418   swig_callbackOnStyleChange = callbackOnStyleChange;
2419   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2420   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2421   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2422   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2423   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2424   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2425   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2426   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2427   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2428   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2429   swig_callbackOnPinch = callbackOnPinch;
2430   swig_callbackOnPan = callbackOnPan;
2431   swig_callbackOnTap = callbackOnTap;
2432   swig_callbackOnLongPress = callbackOnLongPress;
2433   swig_callbackSignalConnected = callbackSignalConnected;
2434   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2435 }
2436
2437 void SwigDirector_ViewImpl::swig_init_callbacks() {
2438   swig_callbackOnStageConnection = 0;
2439   swig_callbackOnStageDisconnection = 0;
2440   swig_callbackOnChildAdd = 0;
2441   swig_callbackOnChildRemove = 0;
2442   swig_callbackOnPropertySet = 0;
2443   swig_callbackOnSizeSet = 0;
2444   swig_callbackOnSizeAnimation = 0;
2445   swig_callbackOnTouchEvent = 0;
2446   swig_callbackOnHoverEvent = 0;
2447   swig_callbackOnKeyEvent = 0;
2448   swig_callbackOnWheelEvent = 0;
2449   swig_callbackOnRelayout = 0;
2450   swig_callbackOnSetResizePolicy = 0;
2451   swig_callbackGetNaturalSize = 0;
2452   swig_callbackCalculateChildSize = 0;
2453   swig_callbackGetHeightForWidth = 0;
2454   swig_callbackGetWidthForHeight = 0;
2455   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2456   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2457   swig_callbackOnCalculateRelayoutSize = 0;
2458   swig_callbackOnLayoutNegotiated = 0;
2459   swig_callbackOnInitialize = 0;
2460   swig_callbackOnControlChildAdd = 0;
2461   swig_callbackOnControlChildRemove = 0;
2462   swig_callbackOnStyleChange = 0;
2463   swig_callbackOnAccessibilityActivated = 0;
2464   swig_callbackOnAccessibilityPan = 0;
2465   swig_callbackOnAccessibilityTouch = 0;
2466   swig_callbackOnAccessibilityValueChange = 0;
2467   swig_callbackOnAccessibilityZoom = 0;
2468   swig_callbackOnKeyInputFocusGained = 0;
2469   swig_callbackOnKeyInputFocusLost = 0;
2470   swig_callbackGetNextKeyboardFocusableActor = 0;
2471   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2472   swig_callbackOnKeyboardEnter = 0;
2473   swig_callbackOnPinch = 0;
2474   swig_callbackOnPan = 0;
2475   swig_callbackOnTap = 0;
2476   swig_callbackOnLongPress = 0;
2477   swig_callbackSignalConnected = 0;
2478   swig_callbackSignalDisconnected = 0;
2479 }
2480
2481 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2482   swig_init_callbacks();
2483 }
2484
2485 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2486
2487 }
2488
2489
2490 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2491   unsigned int c_result = SwigValueInit< unsigned int >() ;
2492   unsigned int jresult = 0 ;
2493
2494   if (!swig_callbackGetNumberOfItems) {
2495     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2496   } else {
2497     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2498     c_result = (unsigned int)jresult;
2499   }
2500   return c_result;
2501 }
2502
2503 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2504   Dali::Actor c_result ;
2505   void * jresult = 0 ;
2506   unsigned int jitemId  ;
2507
2508   if (!swig_callbackNewItem) {
2509     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2510   } else {
2511     jitemId = itemId;
2512     jresult = (void *) swig_callbackNewItem(jitemId);
2513     if (!jresult) {
2514       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2515       return c_result;
2516     }
2517     c_result = *(Dali::Actor *)jresult;
2518   }
2519   return c_result;
2520 }
2521
2522 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2523   unsigned int jitemId  ;
2524   void * jactor  ;
2525
2526   if (!swig_callbackItemReleased) {
2527     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2528     return;
2529   } else {
2530     jitemId = itemId;
2531     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2532     swig_callbackItemReleased(jitemId, jactor);
2533   }
2534 }
2535
2536 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2537   return Dali::Toolkit::ItemFactory::GetExtension();
2538 }
2539
2540 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2541   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2542   swig_callbackNewItem = callbackNewItem;
2543   swig_callbackItemReleased = callbackItemReleased;
2544 }
2545
2546 void SwigDirector_ItemFactory::swig_init_callbacks() {
2547   swig_callbackGetNumberOfItems = 0;
2548   swig_callbackNewItem = 0;
2549   swig_callbackItemReleased = 0;
2550 }
2551
2552 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2553   swig_init_callbacks();
2554 }
2555
2556 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2557
2558 }
2559
2560
2561 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2562   Dali::Actor c_result ;
2563   void * jresult = 0 ;
2564   void * jcurrent  ;
2565   void * jproposed  ;
2566   int jdirection  ;
2567
2568   if (!swig_callbackGetNextFocusableActor) {
2569     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2570   } else {
2571     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2572     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2573     jdirection = (int)direction;
2574     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2575     if (!jresult) {
2576       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__);
2577       return c_result;
2578     }
2579     c_result = *(Dali::Actor *)jresult;
2580   }
2581   return c_result;
2582 }
2583
2584 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2585   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2586 }
2587
2588 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2589   swig_callbackGetNextFocusableActor = 0;
2590 }
2591
2592
2593 #ifdef __cplusplus
2594 extern "C" {
2595 #endif
2596
2597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2598   void * jresult ;
2599   floatp *result = 0 ;
2600
2601   {
2602     try {
2603       result = (floatp *)new_floatp();
2604     } catch (std::out_of_range& e) {
2605       {
2606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2607       };
2608     } catch (std::exception& e) {
2609       {
2610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2611       };
2612     } catch (DaliException e) {
2613       {
2614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2615       };
2616     } catch (...) {
2617       {
2618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2619       };
2620     }
2621   }
2622   jresult = (void *)result;
2623   return jresult;
2624 }
2625
2626
2627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2628   floatp *arg1 = (floatp *) 0 ;
2629
2630   arg1 = (floatp *)jarg1;
2631   {
2632     try {
2633       delete_floatp(arg1);
2634     } catch (std::out_of_range& e) {
2635       {
2636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2637       };
2638     } catch (std::exception& e) {
2639       {
2640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2641       };
2642     } catch (Dali::DaliException e) {
2643       {
2644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2645       };
2646     } catch (...) {
2647       {
2648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2649       };
2650     }
2651   }
2652
2653 }
2654
2655
2656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2657   floatp *arg1 = (floatp *) 0 ;
2658   float arg2 ;
2659
2660   arg1 = (floatp *)jarg1;
2661   arg2 = (float)jarg2;
2662   {
2663     try {
2664       floatp_assign(arg1,arg2);
2665     } catch (std::out_of_range& e) {
2666       {
2667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2668       };
2669     } catch (std::exception& e) {
2670       {
2671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2672       };
2673     } catch (Dali::DaliException e) {
2674       {
2675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2676       };
2677     } catch (...) {
2678       {
2679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2680       };
2681     }
2682   }
2683
2684 }
2685
2686
2687 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2688   float jresult ;
2689   floatp *arg1 = (floatp *) 0 ;
2690   float result;
2691
2692   arg1 = (floatp *)jarg1;
2693   {
2694     try {
2695       result = (float)floatp_value(arg1);
2696     } catch (std::out_of_range& e) {
2697       {
2698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2699       };
2700     } catch (std::exception& e) {
2701       {
2702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2703       };
2704     } catch (DaliException e) {
2705       {
2706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2707       };
2708     } catch (...) {
2709       {
2710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2711       };
2712     }
2713   }
2714   jresult = result;
2715   return jresult;
2716 }
2717
2718
2719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2720   void * jresult ;
2721   floatp *arg1 = (floatp *) 0 ;
2722   float *result = 0 ;
2723
2724   arg1 = (floatp *)jarg1;
2725   {
2726     try {
2727       result = (float *)floatp_cast(arg1);
2728     } catch (std::out_of_range& e) {
2729       {
2730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2731       };
2732     } catch (std::exception& e) {
2733       {
2734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2735       };
2736     } catch (Dali::DaliException e) {
2737       {
2738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2739       };
2740     } catch (...) {
2741       {
2742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2743       };
2744     }
2745   }
2746
2747   jresult = (void *)result;
2748   return jresult;
2749 }
2750
2751
2752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2753   void * jresult ;
2754   float *arg1 = (float *) 0 ;
2755   floatp *result = 0 ;
2756
2757   arg1 = (float *)jarg1;
2758   {
2759     try {
2760       result = (floatp *)floatp_frompointer(arg1);
2761     } catch (std::out_of_range& e) {
2762       {
2763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2764       };
2765     } catch (std::exception& e) {
2766       {
2767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2768       };
2769     } catch (Dali::DaliException e) {
2770       {
2771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2772       };
2773     } catch (...) {
2774       {
2775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2776       };
2777     }
2778   }
2779
2780   jresult = (void *)result;
2781   return jresult;
2782 }
2783
2784
2785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2786   void * jresult ;
2787   intp *result = 0 ;
2788
2789   {
2790     try {
2791       result = (intp *)new_intp();
2792     } catch (std::out_of_range& e) {
2793       {
2794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2795       };
2796     } catch (std::exception& e) {
2797       {
2798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2799       };
2800     } catch (Dali::DaliException e) {
2801       {
2802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2803       };
2804     } catch (...) {
2805       {
2806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2807       };
2808     }
2809   }
2810
2811   jresult = (void *)result;
2812   return jresult;
2813 }
2814
2815
2816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2817   intp *arg1 = (intp *) 0 ;
2818
2819   arg1 = (intp *)jarg1;
2820   {
2821     try {
2822       delete_intp(arg1);
2823     } catch (std::out_of_range& e) {
2824       {
2825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2826       };
2827     } catch (std::exception& e) {
2828       {
2829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2830       };
2831     } catch (Dali::DaliException e) {
2832       {
2833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2834       };
2835     } catch (...) {
2836       {
2837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2838       };
2839     }
2840   }
2841
2842 }
2843
2844
2845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2846   intp *arg1 = (intp *) 0 ;
2847   int arg2 ;
2848
2849   arg1 = (intp *)jarg1;
2850   arg2 = (int)jarg2;
2851   {
2852     try {
2853       intp_assign(arg1,arg2);
2854     } catch (std::out_of_range& e) {
2855       {
2856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2857       };
2858     } catch (std::exception& e) {
2859       {
2860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2861       };
2862     } catch (Dali::DaliException e) {
2863       {
2864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2865       };
2866     } catch (...) {
2867       {
2868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2869       };
2870     }
2871   }
2872
2873 }
2874
2875
2876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2877   int jresult ;
2878   intp *arg1 = (intp *) 0 ;
2879   int result;
2880
2881   arg1 = (intp *)jarg1;
2882   {
2883     try {
2884       result = (int)intp_value(arg1);
2885     } catch (std::out_of_range& e) {
2886       {
2887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2888       };
2889     } catch (std::exception& e) {
2890       {
2891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2892       };
2893     } catch (Dali::DaliException e) {
2894       {
2895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2896       };
2897     } catch (...) {
2898       {
2899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2900       };
2901     }
2902   }
2903
2904   jresult = result;
2905   return jresult;
2906 }
2907
2908
2909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2910   void * jresult ;
2911   intp *arg1 = (intp *) 0 ;
2912   int *result = 0 ;
2913
2914   arg1 = (intp *)jarg1;
2915   {
2916     try {
2917       result = (int *)intp_cast(arg1);
2918     } catch (std::out_of_range& e) {
2919       {
2920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2921       };
2922     } catch (std::exception& e) {
2923       {
2924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2925       };
2926     } catch (Dali::DaliException e) {
2927       {
2928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2929       };
2930     } catch (...) {
2931       {
2932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2933       };
2934     }
2935   }
2936
2937   jresult = (void *)result;
2938   return jresult;
2939 }
2940
2941
2942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2943   void * jresult ;
2944   int *arg1 = (int *) 0 ;
2945   intp *result = 0 ;
2946
2947   arg1 = (int *)jarg1;
2948   {
2949     try {
2950       result = (intp *)intp_frompointer(arg1);
2951     } catch (std::out_of_range& e) {
2952       {
2953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2954       };
2955     } catch (std::exception& e) {
2956       {
2957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2958       };
2959     } catch (Dali::DaliException e) {
2960       {
2961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2962       };
2963     } catch (...) {
2964       {
2965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2966       };
2967     }
2968   }
2969
2970   jresult = (void *)result;
2971   return jresult;
2972 }
2973
2974
2975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2976   void * jresult ;
2977   doublep *result = 0 ;
2978
2979   {
2980     try {
2981       result = (doublep *)new_doublep();
2982     } catch (std::out_of_range& e) {
2983       {
2984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2985       };
2986     } catch (std::exception& e) {
2987       {
2988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2989       };
2990     } catch (Dali::DaliException e) {
2991       {
2992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2993       };
2994     } catch (...) {
2995       {
2996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2997       };
2998     }
2999   }
3000
3001   jresult = (void *)result;
3002   return jresult;
3003 }
3004
3005
3006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
3007   doublep *arg1 = (doublep *) 0 ;
3008
3009   arg1 = (doublep *)jarg1;
3010   {
3011     try {
3012       delete_doublep(arg1);
3013     } catch (std::out_of_range& e) {
3014       {
3015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3016       };
3017     } catch (std::exception& e) {
3018       {
3019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3020       };
3021     } catch (Dali::DaliException e) {
3022       {
3023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3024       };
3025     } catch (...) {
3026       {
3027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3028       };
3029     }
3030   }
3031
3032 }
3033
3034
3035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3036   doublep *arg1 = (doublep *) 0 ;
3037   double arg2 ;
3038
3039   arg1 = (doublep *)jarg1;
3040   arg2 = (double)jarg2;
3041   {
3042     try {
3043       doublep_assign(arg1,arg2);
3044     } catch (std::out_of_range& e) {
3045       {
3046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3047       };
3048     } catch (std::exception& e) {
3049       {
3050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3051       };
3052     } catch (Dali::DaliException e) {
3053       {
3054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3055       };
3056     } catch (...) {
3057       {
3058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3059       };
3060     }
3061   }
3062
3063 }
3064
3065
3066 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3067   double jresult ;
3068   doublep *arg1 = (doublep *) 0 ;
3069   double result;
3070
3071   arg1 = (doublep *)jarg1;
3072   {
3073     try {
3074       result = (double)doublep_value(arg1);
3075     } catch (std::out_of_range& e) {
3076       {
3077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3078       };
3079     } catch (std::exception& e) {
3080       {
3081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3082       };
3083     } catch (Dali::DaliException e) {
3084       {
3085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3086       };
3087     } catch (...) {
3088       {
3089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3090       };
3091     }
3092   }
3093
3094   jresult = result;
3095   return jresult;
3096 }
3097
3098
3099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3100   void * jresult ;
3101   doublep *arg1 = (doublep *) 0 ;
3102   double *result = 0 ;
3103
3104   arg1 = (doublep *)jarg1;
3105   {
3106     try {
3107       result = (double *)doublep_cast(arg1);
3108     } catch (std::out_of_range& e) {
3109       {
3110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3111       };
3112     } catch (std::exception& e) {
3113       {
3114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3115       };
3116     } catch (Dali::DaliException e) {
3117       {
3118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3119       };
3120     } catch (...) {
3121       {
3122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3123       };
3124     }
3125   }
3126
3127   jresult = (void *)result;
3128   return jresult;
3129 }
3130
3131
3132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3133   void * jresult ;
3134   double *arg1 = (double *) 0 ;
3135   doublep *result = 0 ;
3136
3137   arg1 = (double *)jarg1;
3138   {
3139     try {
3140       result = (doublep *)doublep_frompointer(arg1);
3141     } catch (std::out_of_range& e) {
3142       {
3143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3144       };
3145     } catch (std::exception& e) {
3146       {
3147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3148       };
3149     } catch (Dali::DaliException e) {
3150       {
3151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3152       };
3153     } catch (...) {
3154       {
3155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3156       };
3157     }
3158   }
3159
3160   jresult = (void *)result;
3161   return jresult;
3162 }
3163
3164
3165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3166   void * jresult ;
3167   uintp *result = 0 ;
3168
3169   {
3170     try {
3171       result = (uintp *)new_uintp();
3172     } catch (std::out_of_range& e) {
3173       {
3174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3175       };
3176     } catch (std::exception& e) {
3177       {
3178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3179       };
3180     } catch (Dali::DaliException e) {
3181       {
3182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3183       };
3184     } catch (...) {
3185       {
3186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3187       };
3188     }
3189   }
3190
3191   jresult = (void *)result;
3192   return jresult;
3193 }
3194
3195
3196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3197   uintp *arg1 = (uintp *) 0 ;
3198
3199   arg1 = (uintp *)jarg1;
3200   {
3201     try {
3202       delete_uintp(arg1);
3203     } catch (std::out_of_range& e) {
3204       {
3205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3206       };
3207     } catch (std::exception& e) {
3208       {
3209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3210       };
3211     } catch (Dali::DaliException e) {
3212       {
3213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3214       };
3215     } catch (...) {
3216       {
3217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3218       };
3219     }
3220   }
3221
3222 }
3223
3224
3225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3226   uintp *arg1 = (uintp *) 0 ;
3227   unsigned int arg2 ;
3228
3229   arg1 = (uintp *)jarg1;
3230   arg2 = (unsigned int)jarg2;
3231   {
3232     try {
3233       uintp_assign(arg1,arg2);
3234     } catch (std::out_of_range& e) {
3235       {
3236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3237       };
3238     } catch (std::exception& e) {
3239       {
3240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3241       };
3242     } catch (Dali::DaliException e) {
3243       {
3244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3245       };
3246     } catch (...) {
3247       {
3248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3249       };
3250     }
3251   }
3252
3253 }
3254
3255
3256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3257   unsigned int jresult ;
3258   uintp *arg1 = (uintp *) 0 ;
3259   unsigned int result;
3260
3261   arg1 = (uintp *)jarg1;
3262   {
3263     try {
3264       result = (unsigned int)uintp_value(arg1);
3265     } catch (std::out_of_range& e) {
3266       {
3267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3268       };
3269     } catch (std::exception& e) {
3270       {
3271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3272       };
3273     } catch (Dali::DaliException e) {
3274       {
3275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3276       };
3277     } catch (...) {
3278       {
3279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3280       };
3281     }
3282   }
3283
3284   jresult = result;
3285   return jresult;
3286 }
3287
3288
3289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3290   void * jresult ;
3291   uintp *arg1 = (uintp *) 0 ;
3292   unsigned int *result = 0 ;
3293
3294   arg1 = (uintp *)jarg1;
3295   {
3296     try {
3297       result = (unsigned int *)uintp_cast(arg1);
3298     } catch (std::out_of_range& e) {
3299       {
3300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3301       };
3302     } catch (std::exception& e) {
3303       {
3304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3305       };
3306     } catch (Dali::DaliException e) {
3307       {
3308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3309       };
3310     } catch (...) {
3311       {
3312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3313       };
3314     }
3315   }
3316
3317   jresult = (void *)result;
3318   return jresult;
3319 }
3320
3321
3322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3323   void * jresult ;
3324   unsigned int *arg1 = (unsigned int *) 0 ;
3325   uintp *result = 0 ;
3326
3327   arg1 = (unsigned int *)jarg1;
3328   {
3329     try {
3330       result = (uintp *)uintp_frompointer(arg1);
3331     } catch (std::out_of_range& e) {
3332       {
3333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3334       };
3335     } catch (std::exception& e) {
3336       {
3337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3338       };
3339     } catch (Dali::DaliException e) {
3340       {
3341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3342       };
3343     } catch (...) {
3344       {
3345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3346       };
3347     }
3348   }
3349
3350   jresult = (void *)result;
3351   return jresult;
3352 }
3353
3354
3355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3356   void * jresult ;
3357   ushortp *result = 0 ;
3358
3359   {
3360     try {
3361       result = (ushortp *)new_ushortp();
3362     } catch (std::out_of_range& e) {
3363       {
3364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3365       };
3366     } catch (std::exception& e) {
3367       {
3368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3369       };
3370     } catch (Dali::DaliException e) {
3371       {
3372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3373       };
3374     } catch (...) {
3375       {
3376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3377       };
3378     }
3379   }
3380
3381   jresult = (void *)result;
3382   return jresult;
3383 }
3384
3385
3386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3387   ushortp *arg1 = (ushortp *) 0 ;
3388
3389   arg1 = (ushortp *)jarg1;
3390   {
3391     try {
3392       delete_ushortp(arg1);
3393     } catch (std::out_of_range& e) {
3394       {
3395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3396       };
3397     } catch (std::exception& e) {
3398       {
3399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3400       };
3401     } catch (Dali::DaliException e) {
3402       {
3403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3404       };
3405     } catch (...) {
3406       {
3407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3408       };
3409     }
3410   }
3411
3412 }
3413
3414
3415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3416   ushortp *arg1 = (ushortp *) 0 ;
3417   unsigned short arg2 ;
3418
3419   arg1 = (ushortp *)jarg1;
3420   arg2 = (unsigned short)jarg2;
3421   {
3422     try {
3423       ushortp_assign(arg1,arg2);
3424     } catch (std::out_of_range& e) {
3425       {
3426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3427       };
3428     } catch (std::exception& e) {
3429       {
3430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3431       };
3432     } catch (Dali::DaliException e) {
3433       {
3434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3435       };
3436     } catch (...) {
3437       {
3438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3439       };
3440     }
3441   }
3442
3443 }
3444
3445
3446 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3447   unsigned short jresult ;
3448   ushortp *arg1 = (ushortp *) 0 ;
3449   unsigned short result;
3450
3451   arg1 = (ushortp *)jarg1;
3452   {
3453     try {
3454       result = (unsigned short)ushortp_value(arg1);
3455     } catch (std::out_of_range& e) {
3456       {
3457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3458       };
3459     } catch (std::exception& e) {
3460       {
3461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3462       };
3463     } catch (Dali::DaliException e) {
3464       {
3465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3466       };
3467     } catch (...) {
3468       {
3469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3470       };
3471     }
3472   }
3473
3474   jresult = result;
3475   return jresult;
3476 }
3477
3478
3479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3480   void * jresult ;
3481   ushortp *arg1 = (ushortp *) 0 ;
3482   unsigned short *result = 0 ;
3483
3484   arg1 = (ushortp *)jarg1;
3485   {
3486     try {
3487       result = (unsigned short *)ushortp_cast(arg1);
3488     } catch (std::out_of_range& e) {
3489       {
3490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3491       };
3492     } catch (std::exception& e) {
3493       {
3494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3495       };
3496     } catch (Dali::DaliException e) {
3497       {
3498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3499       };
3500     } catch (...) {
3501       {
3502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3503       };
3504     }
3505   }
3506
3507   jresult = (void *)result;
3508   return jresult;
3509 }
3510
3511
3512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3513   void * jresult ;
3514   unsigned short *arg1 = (unsigned short *) 0 ;
3515   ushortp *result = 0 ;
3516
3517   arg1 = (unsigned short *)jarg1;
3518   {
3519     try {
3520       result = (ushortp *)ushortp_frompointer(arg1);
3521     } catch (std::out_of_range& e) {
3522       {
3523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3524       };
3525     } catch (std::exception& e) {
3526       {
3527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3528       };
3529     } catch (Dali::DaliException e) {
3530       {
3531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3532       };
3533     } catch (...) {
3534       {
3535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3536       };
3537     }
3538   }
3539
3540   jresult = (void *)result;
3541   return jresult;
3542 }
3543
3544
3545 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3546   unsigned int jresult ;
3547   int arg1 ;
3548   unsigned int result;
3549
3550   arg1 = (int)jarg1;
3551   {
3552     try {
3553       result = (unsigned int)int_to_uint(arg1);
3554     } catch (std::out_of_range& e) {
3555       {
3556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3557       };
3558     } catch (std::exception& e) {
3559       {
3560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3561       };
3562     } catch (Dali::DaliException e) {
3563       {
3564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3565       };
3566     } catch (...) {
3567       {
3568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3569       };
3570     }
3571   }
3572
3573   jresult = result;
3574   return jresult;
3575 }
3576
3577
3578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3579   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3580
3581   arg1 = (Dali::RefObject *)jarg1;
3582   {
3583     try {
3584       (arg1)->Reference();
3585     } catch (std::out_of_range& e) {
3586       {
3587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3588       };
3589     } catch (std::exception& e) {
3590       {
3591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3592       };
3593     } catch (Dali::DaliException e) {
3594       {
3595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3596       };
3597     } catch (...) {
3598       {
3599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3600       };
3601     }
3602   }
3603
3604 }
3605
3606
3607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3608   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3609
3610   arg1 = (Dali::RefObject *)jarg1;
3611   {
3612     try {
3613       (arg1)->Unreference();
3614     } catch (std::out_of_range& e) {
3615       {
3616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3617       };
3618     } catch (std::exception& e) {
3619       {
3620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3621       };
3622     } catch (Dali::DaliException e) {
3623       {
3624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3625       };
3626     } catch (...) {
3627       {
3628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3629       };
3630     }
3631   }
3632
3633 }
3634
3635
3636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3637   int jresult ;
3638   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3639   int result;
3640
3641   arg1 = (Dali::RefObject *)jarg1;
3642   {
3643     try {
3644       result = (int)(arg1)->ReferenceCount();
3645     } catch (std::out_of_range& e) {
3646       {
3647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3648       };
3649     } catch (std::exception& e) {
3650       {
3651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3652       };
3653     } catch (Dali::DaliException e) {
3654       {
3655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3656       };
3657     } catch (...) {
3658       {
3659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3660       };
3661     }
3662   }
3663
3664   jresult = result;
3665   return jresult;
3666 }
3667
3668
3669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3670   void * jresult ;
3671   Dali::Any *result = 0 ;
3672
3673   {
3674     try {
3675       result = (Dali::Any *)new Dali::Any();
3676     } catch (std::out_of_range& e) {
3677       {
3678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3679       };
3680     } catch (std::exception& e) {
3681       {
3682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3683       };
3684     } catch (Dali::DaliException e) {
3685       {
3686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3687       };
3688     } catch (...) {
3689       {
3690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3691       };
3692     }
3693   }
3694
3695   jresult = (void *)result;
3696   return jresult;
3697 }
3698
3699
3700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3701   Dali::Any *arg1 = (Dali::Any *) 0 ;
3702
3703   arg1 = (Dali::Any *)jarg1;
3704   {
3705     try {
3706       delete arg1;
3707     } catch (std::out_of_range& e) {
3708       {
3709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3710       };
3711     } catch (std::exception& e) {
3712       {
3713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3714       };
3715     } catch (Dali::DaliException e) {
3716       {
3717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3718       };
3719     } catch (...) {
3720       {
3721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3722       };
3723     }
3724   }
3725
3726 }
3727
3728
3729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3730   char *arg1 = (char *) 0 ;
3731
3732   arg1 = (char *)jarg1;
3733   {
3734     try {
3735       Dali::Any::AssertAlways((char const *)arg1);
3736     } catch (std::out_of_range& e) {
3737       {
3738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3739       };
3740     } catch (std::exception& e) {
3741       {
3742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3743       };
3744     } catch (Dali::DaliException e) {
3745       {
3746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3747       };
3748     } catch (...) {
3749       {
3750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3751       };
3752     }
3753   }
3754
3755 }
3756
3757
3758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3759   void * jresult ;
3760   Dali::Any *arg1 = 0 ;
3761   Dali::Any *result = 0 ;
3762
3763   arg1 = (Dali::Any *)jarg1;
3764   if (!arg1) {
3765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3766     return 0;
3767   }
3768   {
3769     try {
3770       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3771     } catch (std::out_of_range& e) {
3772       {
3773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3774       };
3775     } catch (std::exception& e) {
3776       {
3777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3778       };
3779     } catch (Dali::DaliException e) {
3780       {
3781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3782       };
3783     } catch (...) {
3784       {
3785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3786       };
3787     }
3788   }
3789
3790   jresult = (void *)result;
3791   return jresult;
3792 }
3793
3794
3795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3796   void * jresult ;
3797   Dali::Any *arg1 = (Dali::Any *) 0 ;
3798   Dali::Any *arg2 = 0 ;
3799   Dali::Any *result = 0 ;
3800
3801   arg1 = (Dali::Any *)jarg1;
3802   arg2 = (Dali::Any *)jarg2;
3803   if (!arg2) {
3804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3805     return 0;
3806   }
3807   {
3808     try {
3809       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3810     } catch (std::out_of_range& e) {
3811       {
3812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3813       };
3814     } catch (std::exception& e) {
3815       {
3816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3817       };
3818     } catch (Dali::DaliException e) {
3819       {
3820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3821       };
3822     } catch (...) {
3823       {
3824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3825       };
3826     }
3827   }
3828
3829   jresult = (void *)result;
3830   return jresult;
3831 }
3832
3833
3834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3835   void * jresult ;
3836   Dali::Any *arg1 = (Dali::Any *) 0 ;
3837   std::type_info *result = 0 ;
3838
3839   arg1 = (Dali::Any *)jarg1;
3840   {
3841     try {
3842       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3843     } catch (std::out_of_range& e) {
3844       {
3845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3846       };
3847     } catch (std::exception& e) {
3848       {
3849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3850       };
3851     } catch (Dali::DaliException e) {
3852       {
3853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3854       };
3855     } catch (...) {
3856       {
3857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3858       };
3859     }
3860   }
3861
3862   jresult = (void *)result;
3863   return jresult;
3864 }
3865
3866
3867 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3868   unsigned int jresult ;
3869   Dali::Any *arg1 = (Dali::Any *) 0 ;
3870   bool result;
3871
3872   arg1 = (Dali::Any *)jarg1;
3873   {
3874     try {
3875       result = (bool)((Dali::Any const *)arg1)->Empty();
3876     } catch (std::out_of_range& e) {
3877       {
3878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3879       };
3880     } catch (std::exception& e) {
3881       {
3882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3883       };
3884     } catch (Dali::DaliException e) {
3885       {
3886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3887       };
3888     } catch (...) {
3889       {
3890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3891       };
3892     }
3893   }
3894
3895   jresult = result;
3896   return jresult;
3897 }
3898
3899
3900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3901   void * jresult ;
3902   std::type_info *arg1 = 0 ;
3903   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3904   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3905   Dali::Any::AnyContainerBase *result = 0 ;
3906
3907   arg1 = (std::type_info *)jarg1;
3908   if (!arg1) {
3909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3910     return 0;
3911   }
3912   arg2 = (Dali::Any::CloneFunc)jarg2;
3913   arg3 = (Dali::Any::DeleteFunc)jarg3;
3914   {
3915     try {
3916       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3917     } catch (std::out_of_range& e) {
3918       {
3919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3920       };
3921     } catch (std::exception& e) {
3922       {
3923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3924       };
3925     } catch (Dali::DaliException e) {
3926       {
3927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3928       };
3929     } catch (...) {
3930       {
3931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3932       };
3933     }
3934   }
3935
3936   jresult = (void *)result;
3937   return jresult;
3938 }
3939
3940
3941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3942   void * jresult ;
3943   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3944   std::type_info *result = 0 ;
3945
3946   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3947   {
3948     try {
3949       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3950     } catch (std::out_of_range& e) {
3951       {
3952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3953       };
3954     } catch (std::exception& e) {
3955       {
3956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3957       };
3958     } catch (Dali::DaliException e) {
3959       {
3960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3961       };
3962     } catch (...) {
3963       {
3964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3965       };
3966     }
3967   }
3968
3969   jresult = (void *)result;
3970   return jresult;
3971 }
3972
3973
3974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3975   void * jresult ;
3976   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3977   ::std::type_info *result = 0 ;
3978
3979   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3980   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3981   jresult = (void *)result;
3982   return jresult;
3983 }
3984
3985
3986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3987   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3988   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3989
3990   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3991   arg2 = (Dali::Any::CloneFunc)jarg2;
3992   if (arg1) (arg1)->mCloneFunc = arg2;
3993 }
3994
3995
3996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3997   void * jresult ;
3998   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3999   Dali::Any::CloneFunc result;
4000
4001   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4002   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
4003   jresult = (void *)result;
4004   return jresult;
4005 }
4006
4007
4008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
4009   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4010   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
4011
4012   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4013   arg2 = (Dali::Any::DeleteFunc)jarg2;
4014   if (arg1) (arg1)->mDeleteFunc = arg2;
4015 }
4016
4017
4018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4019   void * jresult ;
4020   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4021   Dali::Any::DeleteFunc result;
4022
4023   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4024   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4025   jresult = (void *)result;
4026   return jresult;
4027 }
4028
4029
4030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4031   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4032
4033   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4034   {
4035     try {
4036       delete arg1;
4037     } catch (std::out_of_range& e) {
4038       {
4039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4040       };
4041     } catch (std::exception& e) {
4042       {
4043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4044       };
4045     } catch (Dali::DaliException e) {
4046       {
4047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4048       };
4049     } catch (...) {
4050       {
4051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4052       };
4053     }
4054   }
4055
4056 }
4057
4058
4059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4060   Dali::Any *arg1 = (Dali::Any *) 0 ;
4061   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4062
4063   arg1 = (Dali::Any *)jarg1;
4064   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4065   if (arg1) (arg1)->mContainer = arg2;
4066 }
4067
4068
4069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4070   void * jresult ;
4071   Dali::Any *arg1 = (Dali::Any *) 0 ;
4072   Dali::Any::AnyContainerBase *result = 0 ;
4073
4074   arg1 = (Dali::Any *)jarg1;
4075   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4076   jresult = (void *)result;
4077   return jresult;
4078 }
4079
4080
4081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4082   char *arg1 = (char *) 0 ;
4083   char *arg2 = (char *) 0 ;
4084
4085   arg1 = (char *)jarg1;
4086   arg2 = (char *)jarg2;
4087   {
4088     try {
4089       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4090     } catch (std::out_of_range& e) {
4091       {
4092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4093       };
4094     } catch (std::exception& e) {
4095       {
4096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4097       };
4098     } catch (Dali::DaliException e) {
4099       {
4100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4101       };
4102     } catch (...) {
4103       {
4104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4105       };
4106     }
4107   }
4108
4109 }
4110
4111
4112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4113   void * jresult ;
4114   char *arg1 = (char *) 0 ;
4115   char *arg2 = (char *) 0 ;
4116   Dali::DaliException *result = 0 ;
4117
4118   arg1 = (char *)jarg1;
4119   arg2 = (char *)jarg2;
4120   {
4121     try {
4122       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4123     } catch (std::out_of_range& e) {
4124       {
4125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4126       };
4127     } catch (std::exception& e) {
4128       {
4129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4130       };
4131     } catch (Dali::DaliException e) {
4132       {
4133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4134       };
4135     } catch (...) {
4136       {
4137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4138       };
4139     }
4140   }
4141
4142   jresult = (void *)result;
4143   return jresult;
4144 }
4145
4146
4147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4148   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4149   std::string arg2 = std::string(jarg2);
4150
4151   arg1 = (Dali::DaliException *)jarg1;
4152   {
4153     if (!arg2.empty()) {
4154       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4155     } else {
4156       arg1->location = 0;
4157     }
4158   }
4159 }
4160
4161 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4162   char * jresult ;
4163   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4164   char *result = 0 ;
4165
4166   arg1 = (Dali::DaliException *)jarg1;
4167   result = (char *) ((arg1)->location);
4168   jresult = SWIG_csharp_string_callback((const char *)result);
4169   return jresult;
4170 }
4171
4172
4173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4174   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4175   std::string arg2 = std::string(jarg2);
4176
4177   arg1 = (Dali::DaliException *)jarg1;
4178   {
4179     if (!arg2.empty()) {
4180       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4181     } else {
4182       arg1->condition = 0;
4183     }
4184   }
4185 }
4186
4187
4188 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4189   char * jresult ;
4190   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4191   char *result = 0 ;
4192
4193   arg1 = (Dali::DaliException *)jarg1;
4194   result = (char *) ((arg1)->condition);
4195   jresult = SWIG_csharp_string_callback((const char *)result);
4196   return jresult;
4197 }
4198
4199
4200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4201   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4202
4203   arg1 = (Dali::DaliException *)jarg1;
4204   {
4205     try {
4206       delete arg1;
4207     } catch (std::out_of_range& e) {
4208       {
4209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4210       };
4211     } catch (std::exception& e) {
4212       {
4213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4214       };
4215     } catch (Dali::DaliException e) {
4216       {
4217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4218       };
4219     } catch (...) {
4220       {
4221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4222       };
4223     }
4224   }
4225
4226 }
4227
4228
4229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4230   void * jresult ;
4231   Dali::Vector2 *result = 0 ;
4232
4233   {
4234     try {
4235       result = (Dali::Vector2 *)new Dali::Vector2();
4236     } catch (std::out_of_range& e) {
4237       {
4238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4239       };
4240     } catch (std::exception& e) {
4241       {
4242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4243       };
4244     } catch (Dali::DaliException e) {
4245       {
4246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4247       };
4248     } catch (...) {
4249       {
4250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4251       };
4252     }
4253   }
4254
4255   jresult = (void *)result;
4256   return jresult;
4257 }
4258
4259
4260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4261   void * jresult ;
4262   float arg1 ;
4263   float arg2 ;
4264   Dali::Vector2 *result = 0 ;
4265
4266   arg1 = (float)jarg1;
4267   arg2 = (float)jarg2;
4268   {
4269     try {
4270       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4271     } catch (std::out_of_range& e) {
4272       {
4273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4274       };
4275     } catch (std::exception& e) {
4276       {
4277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4278       };
4279     } catch (Dali::DaliException e) {
4280       {
4281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4282       };
4283     } catch (...) {
4284       {
4285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4286       };
4287     }
4288   }
4289
4290   jresult = (void *)result;
4291   return jresult;
4292 }
4293
4294
4295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4296   void * jresult ;
4297   float *arg1 = (float *) 0 ;
4298   Dali::Vector2 *result = 0 ;
4299
4300   arg1 = jarg1;
4301   {
4302     try {
4303       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4304     } catch (std::out_of_range& e) {
4305       {
4306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4307       };
4308     } catch (std::exception& e) {
4309       {
4310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4311       };
4312     } catch (Dali::DaliException e) {
4313       {
4314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4315       };
4316     } catch (...) {
4317       {
4318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4319       };
4320     }
4321   }
4322
4323   jresult = (void *)result;
4324
4325
4326   return jresult;
4327 }
4328
4329
4330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4331   void * jresult ;
4332   Dali::Vector3 *arg1 = 0 ;
4333   Dali::Vector2 *result = 0 ;
4334
4335   arg1 = (Dali::Vector3 *)jarg1;
4336   if (!arg1) {
4337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4338     return 0;
4339   }
4340   {
4341     try {
4342       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4343     } catch (std::out_of_range& e) {
4344       {
4345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4346       };
4347     } catch (std::exception& e) {
4348       {
4349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4350       };
4351     } catch (Dali::DaliException e) {
4352       {
4353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4354       };
4355     } catch (...) {
4356       {
4357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4358       };
4359     }
4360   }
4361
4362   jresult = (void *)result;
4363   return jresult;
4364 }
4365
4366
4367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4368   void * jresult ;
4369   Dali::Vector4 *arg1 = 0 ;
4370   Dali::Vector2 *result = 0 ;
4371
4372   arg1 = (Dali::Vector4 *)jarg1;
4373   if (!arg1) {
4374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4375     return 0;
4376   }
4377   {
4378     try {
4379       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4380     } catch (std::out_of_range& e) {
4381       {
4382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4383       };
4384     } catch (std::exception& e) {
4385       {
4386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4387       };
4388     } catch (Dali::DaliException e) {
4389       {
4390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4391       };
4392     } catch (...) {
4393       {
4394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4395       };
4396     }
4397   }
4398
4399   jresult = (void *)result;
4400   return jresult;
4401 }
4402
4403
4404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4405   void * jresult ;
4406   Dali::Vector2 *result = 0 ;
4407
4408   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4409   jresult = (void *)result;
4410   return jresult;
4411 }
4412
4413
4414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4415   void * jresult ;
4416   Dali::Vector2 *result = 0 ;
4417
4418   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4419   jresult = (void *)result;
4420   return jresult;
4421 }
4422
4423
4424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4425   void * jresult ;
4426   Dali::Vector2 *result = 0 ;
4427
4428   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4429   jresult = (void *)result;
4430   return jresult;
4431 }
4432
4433
4434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4435   void * jresult ;
4436   Dali::Vector2 *result = 0 ;
4437
4438   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4439   jresult = (void *)result;
4440   return jresult;
4441 }
4442
4443
4444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4445   void * jresult ;
4446   Dali::Vector2 *result = 0 ;
4447
4448   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4449   jresult = (void *)result;
4450   return jresult;
4451 }
4452
4453
4454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4455   void * jresult ;
4456   Dali::Vector2 *result = 0 ;
4457
4458   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4459   jresult = (void *)result;
4460   return jresult;
4461 }
4462
4463
4464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4465   void * jresult ;
4466   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4467   float *arg2 = (float *) 0 ;
4468   Dali::Vector2 *result = 0 ;
4469
4470   arg1 = (Dali::Vector2 *)jarg1;
4471   arg2 = jarg2;
4472   {
4473     try {
4474       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4475     } catch (std::out_of_range& e) {
4476       {
4477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4478       };
4479     } catch (std::exception& e) {
4480       {
4481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4482       };
4483     } catch (Dali::DaliException e) {
4484       {
4485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4486       };
4487     } catch (...) {
4488       {
4489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4490       };
4491     }
4492   }
4493
4494   jresult = (void *)result;
4495
4496
4497   return jresult;
4498 }
4499
4500
4501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4502   void * jresult ;
4503   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4504   Dali::Vector3 *arg2 = 0 ;
4505   Dali::Vector2 *result = 0 ;
4506
4507   arg1 = (Dali::Vector2 *)jarg1;
4508   arg2 = (Dali::Vector3 *)jarg2;
4509   if (!arg2) {
4510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4511     return 0;
4512   }
4513   {
4514     try {
4515       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4516     } catch (std::out_of_range& e) {
4517       {
4518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4519       };
4520     } catch (std::exception& e) {
4521       {
4522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4523       };
4524     } catch (Dali::DaliException e) {
4525       {
4526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4527       };
4528     } catch (...) {
4529       {
4530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4531       };
4532     }
4533   }
4534
4535   jresult = (void *)result;
4536   return jresult;
4537 }
4538
4539
4540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4541   void * jresult ;
4542   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4543   Dali::Vector4 *arg2 = 0 ;
4544   Dali::Vector2 *result = 0 ;
4545
4546   arg1 = (Dali::Vector2 *)jarg1;
4547   arg2 = (Dali::Vector4 *)jarg2;
4548   if (!arg2) {
4549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4550     return 0;
4551   }
4552   {
4553     try {
4554       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4555     } catch (std::out_of_range& e) {
4556       {
4557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4558       };
4559     } catch (std::exception& e) {
4560       {
4561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4562       };
4563     } catch (Dali::DaliException e) {
4564       {
4565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4566       };
4567     } catch (...) {
4568       {
4569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4570       };
4571     }
4572   }
4573
4574   jresult = (void *)result;
4575   return jresult;
4576 }
4577
4578
4579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4580   void * jresult ;
4581   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4582   Dali::Vector2 *arg2 = 0 ;
4583   Dali::Vector2 result;
4584
4585   arg1 = (Dali::Vector2 *)jarg1;
4586   arg2 = (Dali::Vector2 *)jarg2;
4587   if (!arg2) {
4588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4589     return 0;
4590   }
4591   {
4592     try {
4593       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4594     } catch (std::out_of_range& e) {
4595       {
4596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4597       };
4598     } catch (std::exception& e) {
4599       {
4600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4601       };
4602     } catch (Dali::DaliException e) {
4603       {
4604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4605       };
4606     } catch (...) {
4607       {
4608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4609       };
4610     }
4611   }
4612
4613   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4614   return jresult;
4615 }
4616
4617
4618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4619   void * jresult ;
4620   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4621   Dali::Vector2 *arg2 = 0 ;
4622   Dali::Vector2 *result = 0 ;
4623
4624   arg1 = (Dali::Vector2 *)jarg1;
4625   arg2 = (Dali::Vector2 *)jarg2;
4626   if (!arg2) {
4627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4628     return 0;
4629   }
4630   {
4631     try {
4632       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4633     } catch (std::out_of_range& e) {
4634       {
4635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4636       };
4637     } catch (std::exception& e) {
4638       {
4639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4640       };
4641     } catch (Dali::DaliException e) {
4642       {
4643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4644       };
4645     } catch (...) {
4646       {
4647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4648       };
4649     }
4650   }
4651
4652   jresult = (void *)result;
4653   return jresult;
4654 }
4655
4656
4657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4658   void * jresult ;
4659   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4660   Dali::Vector2 *arg2 = 0 ;
4661   Dali::Vector2 result;
4662
4663   arg1 = (Dali::Vector2 *)jarg1;
4664   arg2 = (Dali::Vector2 *)jarg2;
4665   if (!arg2) {
4666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4667     return 0;
4668   }
4669   {
4670     try {
4671       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4672     } catch (std::out_of_range& e) {
4673       {
4674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4675       };
4676     } catch (std::exception& e) {
4677       {
4678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4679       };
4680     } catch (Dali::DaliException e) {
4681       {
4682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4683       };
4684     } catch (...) {
4685       {
4686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4687       };
4688     }
4689   }
4690
4691   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4692   return jresult;
4693 }
4694
4695
4696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4697   void * jresult ;
4698   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4699   Dali::Vector2 *arg2 = 0 ;
4700   Dali::Vector2 *result = 0 ;
4701
4702   arg1 = (Dali::Vector2 *)jarg1;
4703   arg2 = (Dali::Vector2 *)jarg2;
4704   if (!arg2) {
4705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4706     return 0;
4707   }
4708   {
4709     try {
4710       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4711     } catch (std::out_of_range& e) {
4712       {
4713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4714       };
4715     } catch (std::exception& e) {
4716       {
4717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4718       };
4719     } catch (Dali::DaliException e) {
4720       {
4721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4722       };
4723     } catch (...) {
4724       {
4725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4726       };
4727     }
4728   }
4729
4730   jresult = (void *)result;
4731   return jresult;
4732 }
4733
4734
4735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4736   void * jresult ;
4737   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4738   Dali::Vector2 *arg2 = 0 ;
4739   Dali::Vector2 result;
4740
4741   arg1 = (Dali::Vector2 *)jarg1;
4742   arg2 = (Dali::Vector2 *)jarg2;
4743   if (!arg2) {
4744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4745     return 0;
4746   }
4747   {
4748     try {
4749       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4750     } catch (std::out_of_range& e) {
4751       {
4752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4753       };
4754     } catch (std::exception& e) {
4755       {
4756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4757       };
4758     } catch (Dali::DaliException e) {
4759       {
4760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4761       };
4762     } catch (...) {
4763       {
4764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4765       };
4766     }
4767   }
4768
4769   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4770   return jresult;
4771 }
4772
4773
4774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4775   void * jresult ;
4776   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4777   float arg2 ;
4778   Dali::Vector2 result;
4779
4780   arg1 = (Dali::Vector2 *)jarg1;
4781   arg2 = (float)jarg2;
4782   {
4783     try {
4784       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4785     } catch (std::out_of_range& e) {
4786       {
4787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4788       };
4789     } catch (std::exception& e) {
4790       {
4791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4792       };
4793     } catch (Dali::DaliException e) {
4794       {
4795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4796       };
4797     } catch (...) {
4798       {
4799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4800       };
4801     }
4802   }
4803
4804   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4805   return jresult;
4806 }
4807
4808
4809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4810   void * jresult ;
4811   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4812   Dali::Vector2 *arg2 = 0 ;
4813   Dali::Vector2 *result = 0 ;
4814
4815   arg1 = (Dali::Vector2 *)jarg1;
4816   arg2 = (Dali::Vector2 *)jarg2;
4817   if (!arg2) {
4818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4819     return 0;
4820   }
4821   {
4822     try {
4823       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4824     } catch (std::out_of_range& e) {
4825       {
4826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4827       };
4828     } catch (std::exception& e) {
4829       {
4830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4831       };
4832     } catch (Dali::DaliException e) {
4833       {
4834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4835       };
4836     } catch (...) {
4837       {
4838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4839       };
4840     }
4841   }
4842
4843   jresult = (void *)result;
4844   return jresult;
4845 }
4846
4847
4848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4849   void * jresult ;
4850   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4851   float arg2 ;
4852   Dali::Vector2 *result = 0 ;
4853
4854   arg1 = (Dali::Vector2 *)jarg1;
4855   arg2 = (float)jarg2;
4856   {
4857     try {
4858       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4859     } catch (std::out_of_range& e) {
4860       {
4861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4862       };
4863     } catch (std::exception& e) {
4864       {
4865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4866       };
4867     } catch (Dali::DaliException e) {
4868       {
4869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4870       };
4871     } catch (...) {
4872       {
4873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4874       };
4875     }
4876   }
4877
4878   jresult = (void *)result;
4879   return jresult;
4880 }
4881
4882
4883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4884   void * jresult ;
4885   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4886   Dali::Vector2 *arg2 = 0 ;
4887   Dali::Vector2 result;
4888
4889   arg1 = (Dali::Vector2 *)jarg1;
4890   arg2 = (Dali::Vector2 *)jarg2;
4891   if (!arg2) {
4892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4893     return 0;
4894   }
4895   {
4896     try {
4897       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4898     } catch (std::out_of_range& e) {
4899       {
4900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4901       };
4902     } catch (std::exception& e) {
4903       {
4904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4905       };
4906     } catch (Dali::DaliException e) {
4907       {
4908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4909       };
4910     } catch (...) {
4911       {
4912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4913       };
4914     }
4915   }
4916
4917   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4918   return jresult;
4919 }
4920
4921
4922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4923   void * jresult ;
4924   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4925   float arg2 ;
4926   Dali::Vector2 result;
4927
4928   arg1 = (Dali::Vector2 *)jarg1;
4929   arg2 = (float)jarg2;
4930   {
4931     try {
4932       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4933     } catch (std::out_of_range& e) {
4934       {
4935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4936       };
4937     } catch (std::exception& e) {
4938       {
4939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4940       };
4941     } catch (Dali::DaliException e) {
4942       {
4943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4944       };
4945     } catch (...) {
4946       {
4947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4948       };
4949     }
4950   }
4951
4952   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4953   return jresult;
4954 }
4955
4956
4957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4958   void * jresult ;
4959   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4960   Dali::Vector2 *arg2 = 0 ;
4961   Dali::Vector2 *result = 0 ;
4962
4963   arg1 = (Dali::Vector2 *)jarg1;
4964   arg2 = (Dali::Vector2 *)jarg2;
4965   if (!arg2) {
4966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4967     return 0;
4968   }
4969   {
4970     try {
4971       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4972     } catch (std::out_of_range& e) {
4973       {
4974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4975       };
4976     } catch (std::exception& e) {
4977       {
4978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4979       };
4980     } catch (Dali::DaliException e) {
4981       {
4982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4983       };
4984     } catch (...) {
4985       {
4986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4987       };
4988     }
4989   }
4990
4991   jresult = (void *)result;
4992   return jresult;
4993 }
4994
4995
4996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4997   void * jresult ;
4998   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4999   float arg2 ;
5000   Dali::Vector2 *result = 0 ;
5001
5002   arg1 = (Dali::Vector2 *)jarg1;
5003   arg2 = (float)jarg2;
5004   {
5005     try {
5006       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
5007     } catch (std::out_of_range& e) {
5008       {
5009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5010       };
5011     } catch (std::exception& e) {
5012       {
5013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5014       };
5015     } catch (Dali::DaliException e) {
5016       {
5017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5018       };
5019     } catch (...) {
5020       {
5021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5022       };
5023     }
5024   }
5025
5026   jresult = (void *)result;
5027   return jresult;
5028 }
5029
5030
5031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5032   void * jresult ;
5033   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5034   Dali::Vector2 result;
5035
5036   arg1 = (Dali::Vector2 *)jarg1;
5037   {
5038     try {
5039       result = ((Dali::Vector2 const *)arg1)->operator -();
5040     } catch (std::out_of_range& e) {
5041       {
5042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5043       };
5044     } catch (std::exception& e) {
5045       {
5046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5047       };
5048     } catch (Dali::DaliException e) {
5049       {
5050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5051       };
5052     } catch (...) {
5053       {
5054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5055       };
5056     }
5057   }
5058
5059   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5060   return jresult;
5061 }
5062
5063
5064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5065   unsigned int jresult ;
5066   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5067   Dali::Vector2 *arg2 = 0 ;
5068   bool result;
5069
5070   arg1 = (Dali::Vector2 *)jarg1;
5071   arg2 = (Dali::Vector2 *)jarg2;
5072   if (!arg2) {
5073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5074     return 0;
5075   }
5076   {
5077     try {
5078       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5079     } catch (std::out_of_range& e) {
5080       {
5081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5082       };
5083     } catch (std::exception& e) {
5084       {
5085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5086       };
5087     } catch (Dali::DaliException e) {
5088       {
5089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5090       };
5091     } catch (...) {
5092       {
5093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5094       };
5095     }
5096   }
5097
5098   jresult = result;
5099   return jresult;
5100 }
5101
5102
5103 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5104   unsigned int jresult ;
5105   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5106   Dali::Vector2 *arg2 = 0 ;
5107   bool result;
5108
5109   arg1 = (Dali::Vector2 *)jarg1;
5110   arg2 = (Dali::Vector2 *)jarg2;
5111   if (!arg2) {
5112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5113     return 0;
5114   }
5115   {
5116     try {
5117       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5118     } catch (std::out_of_range& e) {
5119       {
5120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5121       };
5122     } catch (std::exception& e) {
5123       {
5124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5125       };
5126     } catch (Dali::DaliException e) {
5127       {
5128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5129       };
5130     } catch (...) {
5131       {
5132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5133       };
5134     }
5135   }
5136
5137   jresult = result;
5138   return jresult;
5139 }
5140
5141
5142 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5143   float jresult ;
5144   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5145   unsigned int arg2 ;
5146   float *result = 0 ;
5147
5148   arg1 = (Dali::Vector2 *)jarg1;
5149   arg2 = (unsigned int)jarg2;
5150   {
5151     try {
5152       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5153     } catch (std::out_of_range& e) {
5154       {
5155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5156       };
5157     } catch (std::exception& e) {
5158       {
5159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5160       };
5161     } catch (Dali::DaliException e) {
5162       {
5163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5164       };
5165     } catch (...) {
5166       {
5167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5168       };
5169     }
5170   }
5171
5172   jresult = *result;
5173   return jresult;
5174 }
5175
5176
5177 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5178   float jresult ;
5179   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5180   float result;
5181
5182   arg1 = (Dali::Vector2 *)jarg1;
5183   {
5184     try {
5185       result = (float)((Dali::Vector2 const *)arg1)->Length();
5186     } catch (std::out_of_range& e) {
5187       {
5188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5189       };
5190     } catch (std::exception& e) {
5191       {
5192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5193       };
5194     } catch (Dali::DaliException e) {
5195       {
5196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5197       };
5198     } catch (...) {
5199       {
5200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5201       };
5202     }
5203   }
5204
5205   jresult = result;
5206   return jresult;
5207 }
5208
5209
5210 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5211   float jresult ;
5212   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5213   float result;
5214
5215   arg1 = (Dali::Vector2 *)jarg1;
5216   {
5217     try {
5218       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5219     } catch (std::out_of_range& e) {
5220       {
5221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5222       };
5223     } catch (std::exception& e) {
5224       {
5225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5226       };
5227     } catch (Dali::DaliException e) {
5228       {
5229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5230       };
5231     } catch (...) {
5232       {
5233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5234       };
5235     }
5236   }
5237
5238   jresult = result;
5239   return jresult;
5240 }
5241
5242
5243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5244   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5245
5246   arg1 = (Dali::Vector2 *)jarg1;
5247   {
5248     try {
5249       (arg1)->Normalize();
5250     } catch (std::out_of_range& e) {
5251       {
5252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5253       };
5254     } catch (std::exception& e) {
5255       {
5256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5257       };
5258     } catch (Dali::DaliException e) {
5259       {
5260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5261       };
5262     } catch (...) {
5263       {
5264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5265       };
5266     }
5267   }
5268
5269 }
5270
5271
5272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5273   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5274   Dali::Vector2 *arg2 = 0 ;
5275   Dali::Vector2 *arg3 = 0 ;
5276
5277   arg1 = (Dali::Vector2 *)jarg1;
5278   arg2 = (Dali::Vector2 *)jarg2;
5279   if (!arg2) {
5280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5281     return ;
5282   }
5283   arg3 = (Dali::Vector2 *)jarg3;
5284   if (!arg3) {
5285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5286     return ;
5287   }
5288   {
5289     try {
5290       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5291     } catch (std::out_of_range& e) {
5292       {
5293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5294       };
5295     } catch (std::exception& e) {
5296       {
5297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5298       };
5299     } catch (Dali::DaliException e) {
5300       {
5301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5302       };
5303     } catch (...) {
5304       {
5305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5306       };
5307     }
5308   }
5309
5310 }
5311
5312
5313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5314   void * jresult ;
5315   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5316   float *result = 0 ;
5317
5318   arg1 = (Dali::Vector2 *)jarg1;
5319   {
5320     try {
5321       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5322     } catch (std::out_of_range& e) {
5323       {
5324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5325       };
5326     } catch (std::exception& e) {
5327       {
5328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5329       };
5330     } catch (Dali::DaliException e) {
5331       {
5332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5333       };
5334     } catch (...) {
5335       {
5336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5337       };
5338     }
5339   }
5340
5341   jresult = (void *)result;
5342   return jresult;
5343 }
5344
5345
5346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5347   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5348   float arg2 ;
5349
5350   arg1 = (Dali::Vector2 *)jarg1;
5351   arg2 = (float)jarg2;
5352   if (arg1) (arg1)->x = arg2;
5353 }
5354
5355
5356 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5357   float jresult ;
5358   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5359   float result;
5360
5361   arg1 = (Dali::Vector2 *)jarg1;
5362   result = (float) ((arg1)->x);
5363   jresult = result;
5364   return jresult;
5365 }
5366
5367
5368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5369   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5370   float arg2 ;
5371
5372   arg1 = (Dali::Vector2 *)jarg1;
5373   arg2 = (float)jarg2;
5374   if (arg1) (arg1)->width = arg2;
5375 }
5376
5377
5378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5379   float jresult ;
5380   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5381   float result;
5382
5383   arg1 = (Dali::Vector2 *)jarg1;
5384   result = (float) ((arg1)->width);
5385   jresult = result;
5386   return jresult;
5387 }
5388
5389
5390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5391   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5392   float arg2 ;
5393
5394   arg1 = (Dali::Vector2 *)jarg1;
5395   arg2 = (float)jarg2;
5396   if (arg1) (arg1)->y = arg2;
5397 }
5398
5399
5400 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5401   float jresult ;
5402   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5403   float result;
5404
5405   arg1 = (Dali::Vector2 *)jarg1;
5406   result = (float) ((arg1)->y);
5407   jresult = result;
5408   return jresult;
5409 }
5410
5411
5412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5413   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5414   float arg2 ;
5415
5416   arg1 = (Dali::Vector2 *)jarg1;
5417   arg2 = (float)jarg2;
5418   if (arg1) (arg1)->height = arg2;
5419 }
5420
5421
5422 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5423   float jresult ;
5424   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5425   float result;
5426
5427   arg1 = (Dali::Vector2 *)jarg1;
5428   result = (float) ((arg1)->height);
5429   jresult = result;
5430   return jresult;
5431 }
5432
5433
5434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5435   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5436
5437   arg1 = (Dali::Vector2 *)jarg1;
5438   {
5439     try {
5440       delete arg1;
5441     } catch (std::out_of_range& e) {
5442       {
5443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5444       };
5445     } catch (std::exception& e) {
5446       {
5447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5448       };
5449     } catch (Dali::DaliException e) {
5450       {
5451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5452       };
5453     } catch (...) {
5454       {
5455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5456       };
5457     }
5458   }
5459
5460 }
5461
5462
5463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5464   void * jresult ;
5465   Dali::Vector2 *arg1 = 0 ;
5466   Dali::Vector2 *arg2 = 0 ;
5467   Dali::Vector2 result;
5468
5469   arg1 = (Dali::Vector2 *)jarg1;
5470   if (!arg1) {
5471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5472     return 0;
5473   }
5474   arg2 = (Dali::Vector2 *)jarg2;
5475   if (!arg2) {
5476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5477     return 0;
5478   }
5479   {
5480     try {
5481       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5482     } catch (std::out_of_range& e) {
5483       {
5484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5485       };
5486     } catch (std::exception& e) {
5487       {
5488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5489       };
5490     } catch (Dali::DaliException e) {
5491       {
5492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5493       };
5494     } catch (...) {
5495       {
5496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5497       };
5498     }
5499   }
5500
5501   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5502   return jresult;
5503 }
5504
5505
5506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5507   void * jresult ;
5508   Dali::Vector2 *arg1 = 0 ;
5509   Dali::Vector2 *arg2 = 0 ;
5510   Dali::Vector2 result;
5511
5512   arg1 = (Dali::Vector2 *)jarg1;
5513   if (!arg1) {
5514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5515     return 0;
5516   }
5517   arg2 = (Dali::Vector2 *)jarg2;
5518   if (!arg2) {
5519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5520     return 0;
5521   }
5522   {
5523     try {
5524       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5525     } catch (std::out_of_range& e) {
5526       {
5527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5528       };
5529     } catch (std::exception& e) {
5530       {
5531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5532       };
5533     } catch (Dali::DaliException e) {
5534       {
5535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5536       };
5537     } catch (...) {
5538       {
5539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5540       };
5541     }
5542   }
5543
5544   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5545   return jresult;
5546 }
5547
5548
5549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5550   void * jresult ;
5551   Dali::Vector2 *arg1 = 0 ;
5552   float *arg2 = 0 ;
5553   float *arg3 = 0 ;
5554   float temp2 ;
5555   float temp3 ;
5556   Dali::Vector2 result;
5557
5558   arg1 = (Dali::Vector2 *)jarg1;
5559   if (!arg1) {
5560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5561     return 0;
5562   }
5563   temp2 = (float)jarg2;
5564   arg2 = &temp2;
5565   temp3 = (float)jarg3;
5566   arg3 = &temp3;
5567   {
5568     try {
5569       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5570     } catch (std::out_of_range& e) {
5571       {
5572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5573       };
5574     } catch (std::exception& e) {
5575       {
5576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5577       };
5578     } catch (Dali::DaliException e) {
5579       {
5580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5581       };
5582     } catch (...) {
5583       {
5584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5585       };
5586     }
5587   }
5588
5589   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5590   return jresult;
5591 }
5592
5593
5594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5595   void * jresult ;
5596   Dali::Vector3 *result = 0 ;
5597
5598   {
5599     try {
5600       result = (Dali::Vector3 *)new Dali::Vector3();
5601     } catch (std::out_of_range& e) {
5602       {
5603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5604       };
5605     } catch (std::exception& e) {
5606       {
5607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5608       };
5609     } catch (Dali::DaliException e) {
5610       {
5611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5612       };
5613     } catch (...) {
5614       {
5615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5616       };
5617     }
5618   }
5619
5620   jresult = (void *)result;
5621   return jresult;
5622 }
5623
5624
5625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5626   void * jresult ;
5627   float arg1 ;
5628   float arg2 ;
5629   float arg3 ;
5630   Dali::Vector3 *result = 0 ;
5631
5632   arg1 = (float)jarg1;
5633   arg2 = (float)jarg2;
5634   arg3 = (float)jarg3;
5635   {
5636     try {
5637       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5638     } catch (std::out_of_range& e) {
5639       {
5640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5641       };
5642     } catch (std::exception& e) {
5643       {
5644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5645       };
5646     } catch (Dali::DaliException e) {
5647       {
5648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5649       };
5650     } catch (...) {
5651       {
5652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5653       };
5654     }
5655   }
5656
5657   jresult = (void *)result;
5658   return jresult;
5659 }
5660
5661
5662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5663   void * jresult ;
5664   float *arg1 = (float *) 0 ;
5665   Dali::Vector3 *result = 0 ;
5666
5667   arg1 = jarg1;
5668   {
5669     try {
5670       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5671     } catch (std::out_of_range& e) {
5672       {
5673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5674       };
5675     } catch (std::exception& e) {
5676       {
5677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5678       };
5679     } catch (Dali::DaliException e) {
5680       {
5681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5682       };
5683     } catch (...) {
5684       {
5685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5686       };
5687     }
5688   }
5689
5690   jresult = (void *)result;
5691
5692
5693   return jresult;
5694 }
5695
5696
5697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5698   void * jresult ;
5699   Dali::Vector2 *arg1 = 0 ;
5700   Dali::Vector3 *result = 0 ;
5701
5702   arg1 = (Dali::Vector2 *)jarg1;
5703   if (!arg1) {
5704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5705     return 0;
5706   }
5707   {
5708     try {
5709       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5710     } catch (std::out_of_range& e) {
5711       {
5712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5713       };
5714     } catch (std::exception& e) {
5715       {
5716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5717       };
5718     } catch (Dali::DaliException e) {
5719       {
5720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5721       };
5722     } catch (...) {
5723       {
5724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5725       };
5726     }
5727   }
5728
5729   jresult = (void *)result;
5730   return jresult;
5731 }
5732
5733
5734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5735   void * jresult ;
5736   Dali::Vector4 *arg1 = 0 ;
5737   Dali::Vector3 *result = 0 ;
5738
5739   arg1 = (Dali::Vector4 *)jarg1;
5740   if (!arg1) {
5741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5742     return 0;
5743   }
5744   {
5745     try {
5746       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5747     } catch (std::out_of_range& e) {
5748       {
5749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5750       };
5751     } catch (std::exception& e) {
5752       {
5753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5754       };
5755     } catch (Dali::DaliException e) {
5756       {
5757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5758       };
5759     } catch (...) {
5760       {
5761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5762       };
5763     }
5764   }
5765
5766   jresult = (void *)result;
5767   return jresult;
5768 }
5769
5770
5771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5772   void * jresult ;
5773   Dali::Vector3 *result = 0 ;
5774
5775   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5776   jresult = (void *)result;
5777   return jresult;
5778 }
5779
5780
5781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5782   void * jresult ;
5783   Dali::Vector3 *result = 0 ;
5784
5785   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5786   jresult = (void *)result;
5787   return jresult;
5788 }
5789
5790
5791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5792   void * jresult ;
5793   Dali::Vector3 *result = 0 ;
5794
5795   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5796   jresult = (void *)result;
5797   return jresult;
5798 }
5799
5800
5801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5802   void * jresult ;
5803   Dali::Vector3 *result = 0 ;
5804
5805   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5806   jresult = (void *)result;
5807   return jresult;
5808 }
5809
5810
5811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5812   void * jresult ;
5813   Dali::Vector3 *result = 0 ;
5814
5815   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5816   jresult = (void *)result;
5817   return jresult;
5818 }
5819
5820
5821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5822   void * jresult ;
5823   Dali::Vector3 *result = 0 ;
5824
5825   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5826   jresult = (void *)result;
5827   return jresult;
5828 }
5829
5830
5831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5832   void * jresult ;
5833   Dali::Vector3 *result = 0 ;
5834
5835   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5836   jresult = (void *)result;
5837   return jresult;
5838 }
5839
5840
5841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5842   void * jresult ;
5843   Dali::Vector3 *result = 0 ;
5844
5845   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5846   jresult = (void *)result;
5847   return jresult;
5848 }
5849
5850
5851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5852   void * jresult ;
5853   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5854   float *arg2 = (float *) 0 ;
5855   Dali::Vector3 *result = 0 ;
5856
5857   arg1 = (Dali::Vector3 *)jarg1;
5858   arg2 = jarg2;
5859   {
5860     try {
5861       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5862     } catch (std::out_of_range& e) {
5863       {
5864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5865       };
5866     } catch (std::exception& e) {
5867       {
5868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5869       };
5870     } catch (Dali::DaliException e) {
5871       {
5872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5873       };
5874     } catch (...) {
5875       {
5876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5877       };
5878     }
5879   }
5880
5881   jresult = (void *)result;
5882
5883
5884   return jresult;
5885 }
5886
5887
5888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5889   void * jresult ;
5890   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5891   Dali::Vector2 *arg2 = 0 ;
5892   Dali::Vector3 *result = 0 ;
5893
5894   arg1 = (Dali::Vector3 *)jarg1;
5895   arg2 = (Dali::Vector2 *)jarg2;
5896   if (!arg2) {
5897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5898     return 0;
5899   }
5900   {
5901     try {
5902       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5903     } catch (std::out_of_range& e) {
5904       {
5905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5906       };
5907     } catch (std::exception& e) {
5908       {
5909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5910       };
5911     } catch (Dali::DaliException e) {
5912       {
5913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5914       };
5915     } catch (...) {
5916       {
5917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5918       };
5919     }
5920   }
5921
5922   jresult = (void *)result;
5923   return jresult;
5924 }
5925
5926
5927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5928   void * jresult ;
5929   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5930   Dali::Vector4 *arg2 = 0 ;
5931   Dali::Vector3 *result = 0 ;
5932
5933   arg1 = (Dali::Vector3 *)jarg1;
5934   arg2 = (Dali::Vector4 *)jarg2;
5935   if (!arg2) {
5936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5937     return 0;
5938   }
5939   {
5940     try {
5941       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5942     } catch (std::out_of_range& e) {
5943       {
5944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5945       };
5946     } catch (std::exception& e) {
5947       {
5948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5949       };
5950     } catch (Dali::DaliException e) {
5951       {
5952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5953       };
5954     } catch (...) {
5955       {
5956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5957       };
5958     }
5959   }
5960
5961   jresult = (void *)result;
5962   return jresult;
5963 }
5964
5965
5966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5967   void * jresult ;
5968   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5969   Dali::Vector3 *arg2 = 0 ;
5970   Dali::Vector3 result;
5971
5972   arg1 = (Dali::Vector3 *)jarg1;
5973   arg2 = (Dali::Vector3 *)jarg2;
5974   if (!arg2) {
5975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5976     return 0;
5977   }
5978   {
5979     try {
5980       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5981     } catch (std::out_of_range& e) {
5982       {
5983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5984       };
5985     } catch (std::exception& e) {
5986       {
5987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5988       };
5989     } catch (Dali::DaliException e) {
5990       {
5991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5992       };
5993     } catch (...) {
5994       {
5995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5996       };
5997     }
5998   }
5999
6000   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6001   return jresult;
6002 }
6003
6004
6005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
6006   void * jresult ;
6007   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6008   Dali::Vector3 *arg2 = 0 ;
6009   Dali::Vector3 *result = 0 ;
6010
6011   arg1 = (Dali::Vector3 *)jarg1;
6012   arg2 = (Dali::Vector3 *)jarg2;
6013   if (!arg2) {
6014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6015     return 0;
6016   }
6017   {
6018     try {
6019       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6020     } catch (std::out_of_range& e) {
6021       {
6022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6023       };
6024     } catch (std::exception& e) {
6025       {
6026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6027       };
6028     } catch (Dali::DaliException e) {
6029       {
6030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6031       };
6032     } catch (...) {
6033       {
6034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6035       };
6036     }
6037   }
6038
6039   jresult = (void *)result;
6040   return jresult;
6041 }
6042
6043
6044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6045   void * jresult ;
6046   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6047   Dali::Vector3 *arg2 = 0 ;
6048   Dali::Vector3 result;
6049
6050   arg1 = (Dali::Vector3 *)jarg1;
6051   arg2 = (Dali::Vector3 *)jarg2;
6052   if (!arg2) {
6053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6054     return 0;
6055   }
6056   {
6057     try {
6058       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6059     } catch (std::out_of_range& e) {
6060       {
6061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6062       };
6063     } catch (std::exception& e) {
6064       {
6065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6066       };
6067     } catch (Dali::DaliException e) {
6068       {
6069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6070       };
6071     } catch (...) {
6072       {
6073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6074       };
6075     }
6076   }
6077
6078   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6079   return jresult;
6080 }
6081
6082
6083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6084   void * jresult ;
6085   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6086   Dali::Vector3 *arg2 = 0 ;
6087   Dali::Vector3 *result = 0 ;
6088
6089   arg1 = (Dali::Vector3 *)jarg1;
6090   arg2 = (Dali::Vector3 *)jarg2;
6091   if (!arg2) {
6092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6093     return 0;
6094   }
6095   {
6096     try {
6097       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6098     } catch (std::out_of_range& e) {
6099       {
6100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6101       };
6102     } catch (std::exception& e) {
6103       {
6104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6105       };
6106     } catch (Dali::DaliException e) {
6107       {
6108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6109       };
6110     } catch (...) {
6111       {
6112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6113       };
6114     }
6115   }
6116
6117   jresult = (void *)result;
6118   return jresult;
6119 }
6120
6121
6122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6123   void * jresult ;
6124   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6125   Dali::Vector3 *arg2 = 0 ;
6126   Dali::Vector3 result;
6127
6128   arg1 = (Dali::Vector3 *)jarg1;
6129   arg2 = (Dali::Vector3 *)jarg2;
6130   if (!arg2) {
6131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6132     return 0;
6133   }
6134   {
6135     try {
6136       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6137     } catch (std::out_of_range& e) {
6138       {
6139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6140       };
6141     } catch (std::exception& e) {
6142       {
6143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6144       };
6145     } catch (Dali::DaliException e) {
6146       {
6147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6148       };
6149     } catch (...) {
6150       {
6151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6152       };
6153     }
6154   }
6155
6156   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6157   return jresult;
6158 }
6159
6160
6161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6162   void * jresult ;
6163   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6164   float arg2 ;
6165   Dali::Vector3 result;
6166
6167   arg1 = (Dali::Vector3 *)jarg1;
6168   arg2 = (float)jarg2;
6169   {
6170     try {
6171       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6172     } catch (std::out_of_range& e) {
6173       {
6174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6175       };
6176     } catch (std::exception& e) {
6177       {
6178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6179       };
6180     } catch (Dali::DaliException e) {
6181       {
6182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6183       };
6184     } catch (...) {
6185       {
6186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6187       };
6188     }
6189   }
6190
6191   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6192   return jresult;
6193 }
6194
6195
6196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6197   void * jresult ;
6198   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6199   Dali::Vector3 *arg2 = 0 ;
6200   Dali::Vector3 *result = 0 ;
6201
6202   arg1 = (Dali::Vector3 *)jarg1;
6203   arg2 = (Dali::Vector3 *)jarg2;
6204   if (!arg2) {
6205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6206     return 0;
6207   }
6208   {
6209     try {
6210       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6211     } catch (std::out_of_range& e) {
6212       {
6213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6214       };
6215     } catch (std::exception& e) {
6216       {
6217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6218       };
6219     } catch (Dali::DaliException e) {
6220       {
6221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6222       };
6223     } catch (...) {
6224       {
6225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6226       };
6227     }
6228   }
6229
6230   jresult = (void *)result;
6231   return jresult;
6232 }
6233
6234
6235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6236   void * jresult ;
6237   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6238   float arg2 ;
6239   Dali::Vector3 *result = 0 ;
6240
6241   arg1 = (Dali::Vector3 *)jarg1;
6242   arg2 = (float)jarg2;
6243   {
6244     try {
6245       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6246     } catch (std::out_of_range& e) {
6247       {
6248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6249       };
6250     } catch (std::exception& e) {
6251       {
6252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6253       };
6254     } catch (Dali::DaliException e) {
6255       {
6256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6257       };
6258     } catch (...) {
6259       {
6260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6261       };
6262     }
6263   }
6264
6265   jresult = (void *)result;
6266   return jresult;
6267 }
6268
6269
6270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6271   void * jresult ;
6272   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6273   Dali::Quaternion *arg2 = 0 ;
6274   Dali::Vector3 *result = 0 ;
6275
6276   arg1 = (Dali::Vector3 *)jarg1;
6277   arg2 = (Dali::Quaternion *)jarg2;
6278   if (!arg2) {
6279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6280     return 0;
6281   }
6282   {
6283     try {
6284       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6285     } catch (std::out_of_range& e) {
6286       {
6287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6288       };
6289     } catch (std::exception& e) {
6290       {
6291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6292       };
6293     } catch (Dali::DaliException e) {
6294       {
6295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6296       };
6297     } catch (...) {
6298       {
6299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6300       };
6301     }
6302   }
6303
6304   jresult = (void *)result;
6305   return jresult;
6306 }
6307
6308
6309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6310   void * jresult ;
6311   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6312   Dali::Vector3 *arg2 = 0 ;
6313   Dali::Vector3 result;
6314
6315   arg1 = (Dali::Vector3 *)jarg1;
6316   arg2 = (Dali::Vector3 *)jarg2;
6317   if (!arg2) {
6318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6319     return 0;
6320   }
6321   {
6322     try {
6323       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6324     } catch (std::out_of_range& e) {
6325       {
6326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6327       };
6328     } catch (std::exception& e) {
6329       {
6330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6331       };
6332     } catch (Dali::DaliException e) {
6333       {
6334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6335       };
6336     } catch (...) {
6337       {
6338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6339       };
6340     }
6341   }
6342
6343   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6344   return jresult;
6345 }
6346
6347
6348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6349   void * jresult ;
6350   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6351   float arg2 ;
6352   Dali::Vector3 result;
6353
6354   arg1 = (Dali::Vector3 *)jarg1;
6355   arg2 = (float)jarg2;
6356   {
6357     try {
6358       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6359     } catch (std::out_of_range& e) {
6360       {
6361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6362       };
6363     } catch (std::exception& e) {
6364       {
6365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6366       };
6367     } catch (Dali::DaliException e) {
6368       {
6369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6370       };
6371     } catch (...) {
6372       {
6373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6374       };
6375     }
6376   }
6377
6378   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6379   return jresult;
6380 }
6381
6382
6383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6384   void * jresult ;
6385   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6386   Dali::Vector3 *arg2 = 0 ;
6387   Dali::Vector3 *result = 0 ;
6388
6389   arg1 = (Dali::Vector3 *)jarg1;
6390   arg2 = (Dali::Vector3 *)jarg2;
6391   if (!arg2) {
6392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6393     return 0;
6394   }
6395   {
6396     try {
6397       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6398     } catch (std::out_of_range& e) {
6399       {
6400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6401       };
6402     } catch (std::exception& e) {
6403       {
6404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6405       };
6406     } catch (Dali::DaliException e) {
6407       {
6408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6409       };
6410     } catch (...) {
6411       {
6412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6413       };
6414     }
6415   }
6416
6417   jresult = (void *)result;
6418   return jresult;
6419 }
6420
6421
6422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6423   void * jresult ;
6424   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6425   float arg2 ;
6426   Dali::Vector3 *result = 0 ;
6427
6428   arg1 = (Dali::Vector3 *)jarg1;
6429   arg2 = (float)jarg2;
6430   {
6431     try {
6432       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6433     } catch (std::out_of_range& e) {
6434       {
6435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6436       };
6437     } catch (std::exception& e) {
6438       {
6439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6440       };
6441     } catch (Dali::DaliException e) {
6442       {
6443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6444       };
6445     } catch (...) {
6446       {
6447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6448       };
6449     }
6450   }
6451
6452   jresult = (void *)result;
6453   return jresult;
6454 }
6455
6456
6457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6458   void * jresult ;
6459   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6460   Dali::Vector3 result;
6461
6462   arg1 = (Dali::Vector3 *)jarg1;
6463   {
6464     try {
6465       result = ((Dali::Vector3 const *)arg1)->operator -();
6466     } catch (std::out_of_range& e) {
6467       {
6468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6469       };
6470     } catch (std::exception& e) {
6471       {
6472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6473       };
6474     } catch (Dali::DaliException e) {
6475       {
6476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6477       };
6478     } catch (...) {
6479       {
6480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6481       };
6482     }
6483   }
6484
6485   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6486   return jresult;
6487 }
6488
6489
6490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6491   unsigned int jresult ;
6492   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6493   Dali::Vector3 *arg2 = 0 ;
6494   bool result;
6495
6496   arg1 = (Dali::Vector3 *)jarg1;
6497   arg2 = (Dali::Vector3 *)jarg2;
6498   if (!arg2) {
6499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6500     return 0;
6501   }
6502   {
6503     try {
6504       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6505     } catch (std::out_of_range& e) {
6506       {
6507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6508       };
6509     } catch (std::exception& e) {
6510       {
6511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6512       };
6513     } catch (Dali::DaliException e) {
6514       {
6515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6516       };
6517     } catch (...) {
6518       {
6519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6520       };
6521     }
6522   }
6523
6524   jresult = result;
6525   return jresult;
6526 }
6527
6528
6529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6530   unsigned int jresult ;
6531   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6532   Dali::Vector3 *arg2 = 0 ;
6533   bool result;
6534
6535   arg1 = (Dali::Vector3 *)jarg1;
6536   arg2 = (Dali::Vector3 *)jarg2;
6537   if (!arg2) {
6538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6539     return 0;
6540   }
6541   {
6542     try {
6543       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6544     } catch (std::out_of_range& e) {
6545       {
6546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6547       };
6548     } catch (std::exception& e) {
6549       {
6550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6551       };
6552     } catch (Dali::DaliException e) {
6553       {
6554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6555       };
6556     } catch (...) {
6557       {
6558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6559       };
6560     }
6561   }
6562
6563   jresult = result;
6564   return jresult;
6565 }
6566
6567
6568 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6569   float jresult ;
6570   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6571   unsigned int arg2 ;
6572   float *result = 0 ;
6573
6574   arg1 = (Dali::Vector3 *)jarg1;
6575   arg2 = (unsigned int)jarg2;
6576   {
6577     try {
6578       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6579     } catch (std::out_of_range& e) {
6580       {
6581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6582       };
6583     } catch (std::exception& e) {
6584       {
6585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6586       };
6587     } catch (Dali::DaliException e) {
6588       {
6589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6590       };
6591     } catch (...) {
6592       {
6593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6594       };
6595     }
6596   }
6597
6598   jresult = *result;
6599   return jresult;
6600 }
6601
6602
6603 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6604   float jresult ;
6605   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6606   Dali::Vector3 *arg2 = 0 ;
6607   float result;
6608
6609   arg1 = (Dali::Vector3 *)jarg1;
6610   arg2 = (Dali::Vector3 *)jarg2;
6611   if (!arg2) {
6612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6613     return 0;
6614   }
6615   {
6616     try {
6617       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6618     } catch (std::out_of_range& e) {
6619       {
6620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6621       };
6622     } catch (std::exception& e) {
6623       {
6624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6625       };
6626     } catch (Dali::DaliException e) {
6627       {
6628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6629       };
6630     } catch (...) {
6631       {
6632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6633       };
6634     }
6635   }
6636
6637   jresult = result;
6638   return jresult;
6639 }
6640
6641
6642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6643   void * jresult ;
6644   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6645   Dali::Vector3 *arg2 = 0 ;
6646   Dali::Vector3 result;
6647
6648   arg1 = (Dali::Vector3 *)jarg1;
6649   arg2 = (Dali::Vector3 *)jarg2;
6650   if (!arg2) {
6651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6652     return 0;
6653   }
6654   {
6655     try {
6656       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6657     } catch (std::out_of_range& e) {
6658       {
6659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6660       };
6661     } catch (std::exception& e) {
6662       {
6663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6664       };
6665     } catch (Dali::DaliException e) {
6666       {
6667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6668       };
6669     } catch (...) {
6670       {
6671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6672       };
6673     }
6674   }
6675
6676   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6677   return jresult;
6678 }
6679
6680
6681 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6682   float jresult ;
6683   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6684   float result;
6685
6686   arg1 = (Dali::Vector3 *)jarg1;
6687   {
6688     try {
6689       result = (float)((Dali::Vector3 const *)arg1)->Length();
6690     } catch (std::out_of_range& e) {
6691       {
6692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6693       };
6694     } catch (std::exception& e) {
6695       {
6696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6697       };
6698     } catch (Dali::DaliException e) {
6699       {
6700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6701       };
6702     } catch (...) {
6703       {
6704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6705       };
6706     }
6707   }
6708
6709   jresult = result;
6710   return jresult;
6711 }
6712
6713
6714 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6715   float jresult ;
6716   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6717   float result;
6718
6719   arg1 = (Dali::Vector3 *)jarg1;
6720   {
6721     try {
6722       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6723     } catch (std::out_of_range& e) {
6724       {
6725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6726       };
6727     } catch (std::exception& e) {
6728       {
6729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6730       };
6731     } catch (Dali::DaliException e) {
6732       {
6733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6734       };
6735     } catch (...) {
6736       {
6737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6738       };
6739     }
6740   }
6741
6742   jresult = result;
6743   return jresult;
6744 }
6745
6746
6747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6748   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6749
6750   arg1 = (Dali::Vector3 *)jarg1;
6751   {
6752     try {
6753       (arg1)->Normalize();
6754     } catch (std::out_of_range& e) {
6755       {
6756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6757       };
6758     } catch (std::exception& e) {
6759       {
6760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6761       };
6762     } catch (Dali::DaliException e) {
6763       {
6764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6765       };
6766     } catch (...) {
6767       {
6768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6769       };
6770     }
6771   }
6772
6773 }
6774
6775
6776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6777   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6778   Dali::Vector3 *arg2 = 0 ;
6779   Dali::Vector3 *arg3 = 0 ;
6780
6781   arg1 = (Dali::Vector3 *)jarg1;
6782   arg2 = (Dali::Vector3 *)jarg2;
6783   if (!arg2) {
6784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6785     return ;
6786   }
6787   arg3 = (Dali::Vector3 *)jarg3;
6788   if (!arg3) {
6789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6790     return ;
6791   }
6792   {
6793     try {
6794       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6795     } catch (std::out_of_range& e) {
6796       {
6797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6798       };
6799     } catch (std::exception& e) {
6800       {
6801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6802       };
6803     } catch (Dali::DaliException e) {
6804       {
6805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6806       };
6807     } catch (...) {
6808       {
6809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6810       };
6811     }
6812   }
6813
6814 }
6815
6816
6817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6818   void * jresult ;
6819   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6820   float *result = 0 ;
6821
6822   arg1 = (Dali::Vector3 *)jarg1;
6823   {
6824     try {
6825       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6826     } catch (std::out_of_range& e) {
6827       {
6828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6829       };
6830     } catch (std::exception& e) {
6831       {
6832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6833       };
6834     } catch (Dali::DaliException e) {
6835       {
6836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6837       };
6838     } catch (...) {
6839       {
6840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6841       };
6842     }
6843   }
6844
6845   jresult = (void *)result;
6846   return jresult;
6847 }
6848
6849
6850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6851   void * jresult ;
6852   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6853   Dali::Vector2 *result = 0 ;
6854
6855   arg1 = (Dali::Vector3 *)jarg1;
6856   {
6857     try {
6858       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6859     } catch (std::out_of_range& e) {
6860       {
6861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6862       };
6863     } catch (std::exception& e) {
6864       {
6865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6866       };
6867     } catch (Dali::DaliException e) {
6868       {
6869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6870       };
6871     } catch (...) {
6872       {
6873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6874       };
6875     }
6876   }
6877
6878   jresult = (void *)result;
6879   return jresult;
6880 }
6881
6882
6883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6884   void * jresult ;
6885   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6886   Dali::Vector2 *result = 0 ;
6887
6888   arg1 = (Dali::Vector3 *)jarg1;
6889   {
6890     try {
6891       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6892     } catch (std::out_of_range& e) {
6893       {
6894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6895       };
6896     } catch (std::exception& e) {
6897       {
6898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6899       };
6900     } catch (Dali::DaliException e) {
6901       {
6902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6903       };
6904     } catch (...) {
6905       {
6906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6907       };
6908     }
6909   }
6910
6911   jresult = (void *)result;
6912   return jresult;
6913 }
6914
6915
6916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6917   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6918   float arg2 ;
6919
6920   arg1 = (Dali::Vector3 *)jarg1;
6921   arg2 = (float)jarg2;
6922   if (arg1) (arg1)->x = arg2;
6923 }
6924
6925
6926 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6927   float jresult ;
6928   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6929   float result;
6930
6931   arg1 = (Dali::Vector3 *)jarg1;
6932   result = (float) ((arg1)->x);
6933   jresult = result;
6934   return jresult;
6935 }
6936
6937
6938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6939   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6940   float arg2 ;
6941
6942   arg1 = (Dali::Vector3 *)jarg1;
6943   arg2 = (float)jarg2;
6944   if (arg1) (arg1)->width = arg2;
6945 }
6946
6947
6948 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6949   float jresult ;
6950   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6951   float result;
6952
6953   arg1 = (Dali::Vector3 *)jarg1;
6954   result = (float) ((arg1)->width);
6955   jresult = result;
6956   return jresult;
6957 }
6958
6959
6960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6961   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6962   float arg2 ;
6963
6964   arg1 = (Dali::Vector3 *)jarg1;
6965   arg2 = (float)jarg2;
6966   if (arg1) (arg1)->r = arg2;
6967 }
6968
6969
6970 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6971   float jresult ;
6972   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6973   float result;
6974
6975   arg1 = (Dali::Vector3 *)jarg1;
6976   result = (float) ((arg1)->r);
6977   jresult = result;
6978   return jresult;
6979 }
6980
6981
6982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6983   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6984   float arg2 ;
6985
6986   arg1 = (Dali::Vector3 *)jarg1;
6987   arg2 = (float)jarg2;
6988   if (arg1) (arg1)->y = arg2;
6989 }
6990
6991
6992 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6993   float jresult ;
6994   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6995   float result;
6996
6997   arg1 = (Dali::Vector3 *)jarg1;
6998   result = (float) ((arg1)->y);
6999   jresult = result;
7000   return jresult;
7001 }
7002
7003
7004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
7005   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7006   float arg2 ;
7007
7008   arg1 = (Dali::Vector3 *)jarg1;
7009   arg2 = (float)jarg2;
7010   if (arg1) (arg1)->height = arg2;
7011 }
7012
7013
7014 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
7015   float jresult ;
7016   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7017   float result;
7018
7019   arg1 = (Dali::Vector3 *)jarg1;
7020   result = (float) ((arg1)->height);
7021   jresult = result;
7022   return jresult;
7023 }
7024
7025
7026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7027   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7028   float arg2 ;
7029
7030   arg1 = (Dali::Vector3 *)jarg1;
7031   arg2 = (float)jarg2;
7032   if (arg1) (arg1)->g = arg2;
7033 }
7034
7035
7036 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7037   float jresult ;
7038   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7039   float result;
7040
7041   arg1 = (Dali::Vector3 *)jarg1;
7042   result = (float) ((arg1)->g);
7043   jresult = result;
7044   return jresult;
7045 }
7046
7047
7048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7049   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7050   float arg2 ;
7051
7052   arg1 = (Dali::Vector3 *)jarg1;
7053   arg2 = (float)jarg2;
7054   if (arg1) (arg1)->z = arg2;
7055 }
7056
7057
7058 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7059   float jresult ;
7060   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7061   float result;
7062
7063   arg1 = (Dali::Vector3 *)jarg1;
7064   result = (float) ((arg1)->z);
7065   jresult = result;
7066   return jresult;
7067 }
7068
7069
7070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7071   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7072   float arg2 ;
7073
7074   arg1 = (Dali::Vector3 *)jarg1;
7075   arg2 = (float)jarg2;
7076   if (arg1) (arg1)->depth = arg2;
7077 }
7078
7079
7080 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7081   float jresult ;
7082   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7083   float result;
7084
7085   arg1 = (Dali::Vector3 *)jarg1;
7086   result = (float) ((arg1)->depth);
7087   jresult = result;
7088   return jresult;
7089 }
7090
7091
7092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7093   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7094   float arg2 ;
7095
7096   arg1 = (Dali::Vector3 *)jarg1;
7097   arg2 = (float)jarg2;
7098   if (arg1) (arg1)->b = arg2;
7099 }
7100
7101
7102 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7103   float jresult ;
7104   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7105   float result;
7106
7107   arg1 = (Dali::Vector3 *)jarg1;
7108   result = (float) ((arg1)->b);
7109   jresult = result;
7110   return jresult;
7111 }
7112
7113
7114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7115   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7116
7117   arg1 = (Dali::Vector3 *)jarg1;
7118   {
7119     try {
7120       delete arg1;
7121     } catch (std::out_of_range& e) {
7122       {
7123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7124       };
7125     } catch (std::exception& e) {
7126       {
7127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7128       };
7129     } catch (Dali::DaliException e) {
7130       {
7131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7132       };
7133     } catch (...) {
7134       {
7135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7136       };
7137     }
7138   }
7139
7140 }
7141
7142
7143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7144   void * jresult ;
7145   Dali::Vector3 *arg1 = 0 ;
7146   Dali::Vector3 *arg2 = 0 ;
7147   Dali::Vector3 result;
7148
7149   arg1 = (Dali::Vector3 *)jarg1;
7150   if (!arg1) {
7151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7152     return 0;
7153   }
7154   arg2 = (Dali::Vector3 *)jarg2;
7155   if (!arg2) {
7156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7157     return 0;
7158   }
7159   {
7160     try {
7161       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7162     } catch (std::out_of_range& e) {
7163       {
7164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7165       };
7166     } catch (std::exception& e) {
7167       {
7168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7169       };
7170     } catch (Dali::DaliException e) {
7171       {
7172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7173       };
7174     } catch (...) {
7175       {
7176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7177       };
7178     }
7179   }
7180
7181   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7182   return jresult;
7183 }
7184
7185
7186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7187   void * jresult ;
7188   Dali::Vector3 *arg1 = 0 ;
7189   Dali::Vector3 *arg2 = 0 ;
7190   Dali::Vector3 result;
7191
7192   arg1 = (Dali::Vector3 *)jarg1;
7193   if (!arg1) {
7194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7195     return 0;
7196   }
7197   arg2 = (Dali::Vector3 *)jarg2;
7198   if (!arg2) {
7199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7200     return 0;
7201   }
7202   {
7203     try {
7204       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7205     } catch (std::out_of_range& e) {
7206       {
7207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7208       };
7209     } catch (std::exception& e) {
7210       {
7211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7212       };
7213     } catch (Dali::DaliException e) {
7214       {
7215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7216       };
7217     } catch (...) {
7218       {
7219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7220       };
7221     }
7222   }
7223
7224   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7225   return jresult;
7226 }
7227
7228
7229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7230   void * jresult ;
7231   Dali::Vector3 *arg1 = 0 ;
7232   float *arg2 = 0 ;
7233   float *arg3 = 0 ;
7234   float temp2 ;
7235   float temp3 ;
7236   Dali::Vector3 result;
7237
7238   arg1 = (Dali::Vector3 *)jarg1;
7239   if (!arg1) {
7240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7241     return 0;
7242   }
7243   temp2 = (float)jarg2;
7244   arg2 = &temp2;
7245   temp3 = (float)jarg3;
7246   arg3 = &temp3;
7247   {
7248     try {
7249       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7250     } catch (std::out_of_range& e) {
7251       {
7252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7253       };
7254     } catch (std::exception& e) {
7255       {
7256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7257       };
7258     } catch (Dali::DaliException e) {
7259       {
7260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7261       };
7262     } catch (...) {
7263       {
7264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7265       };
7266     }
7267   }
7268
7269   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7270   return jresult;
7271 }
7272
7273
7274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7275   void * jresult ;
7276   Dali::Vector4 *result = 0 ;
7277
7278   {
7279     try {
7280       result = (Dali::Vector4 *)new Dali::Vector4();
7281     } catch (std::out_of_range& e) {
7282       {
7283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7284       };
7285     } catch (std::exception& e) {
7286       {
7287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7288       };
7289     } catch (Dali::DaliException e) {
7290       {
7291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7292       };
7293     } catch (...) {
7294       {
7295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7296       };
7297     }
7298   }
7299
7300   jresult = (void *)result;
7301   return jresult;
7302 }
7303
7304
7305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7306   void * jresult ;
7307   float arg1 ;
7308   float arg2 ;
7309   float arg3 ;
7310   float arg4 ;
7311   Dali::Vector4 *result = 0 ;
7312
7313   arg1 = (float)jarg1;
7314   arg2 = (float)jarg2;
7315   arg3 = (float)jarg3;
7316   arg4 = (float)jarg4;
7317   {
7318     try {
7319       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7320     } catch (std::out_of_range& e) {
7321       {
7322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7323       };
7324     } catch (std::exception& e) {
7325       {
7326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7327       };
7328     } catch (Dali::DaliException e) {
7329       {
7330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7331       };
7332     } catch (...) {
7333       {
7334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7335       };
7336     }
7337   }
7338
7339   jresult = (void *)result;
7340   return jresult;
7341 }
7342
7343
7344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7345   void * jresult ;
7346   float *arg1 = (float *) 0 ;
7347   Dali::Vector4 *result = 0 ;
7348
7349   arg1 = jarg1;
7350   {
7351     try {
7352       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7353     } catch (std::out_of_range& e) {
7354       {
7355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7356       };
7357     } catch (std::exception& e) {
7358       {
7359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7360       };
7361     } catch (Dali::DaliException e) {
7362       {
7363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7364       };
7365     } catch (...) {
7366       {
7367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7368       };
7369     }
7370   }
7371
7372   jresult = (void *)result;
7373
7374
7375   return jresult;
7376 }
7377
7378
7379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7380   void * jresult ;
7381   Dali::Vector2 *arg1 = 0 ;
7382   Dali::Vector4 *result = 0 ;
7383
7384   arg1 = (Dali::Vector2 *)jarg1;
7385   if (!arg1) {
7386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7387     return 0;
7388   }
7389   {
7390     try {
7391       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7392     } catch (std::out_of_range& e) {
7393       {
7394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7395       };
7396     } catch (std::exception& e) {
7397       {
7398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7399       };
7400     } catch (Dali::DaliException e) {
7401       {
7402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7403       };
7404     } catch (...) {
7405       {
7406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7407       };
7408     }
7409   }
7410
7411   jresult = (void *)result;
7412   return jresult;
7413 }
7414
7415
7416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7417   void * jresult ;
7418   Dali::Vector3 *arg1 = 0 ;
7419   Dali::Vector4 *result = 0 ;
7420
7421   arg1 = (Dali::Vector3 *)jarg1;
7422   if (!arg1) {
7423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7424     return 0;
7425   }
7426   {
7427     try {
7428       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7429     } catch (std::out_of_range& e) {
7430       {
7431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7432       };
7433     } catch (std::exception& e) {
7434       {
7435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7436       };
7437     } catch (Dali::DaliException e) {
7438       {
7439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7440       };
7441     } catch (...) {
7442       {
7443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7444       };
7445     }
7446   }
7447
7448   jresult = (void *)result;
7449   return jresult;
7450 }
7451
7452
7453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7454   void * jresult ;
7455   Dali::Vector4 *result = 0 ;
7456
7457   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7458   jresult = (void *)result;
7459   return jresult;
7460 }
7461
7462
7463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7464   void * jresult ;
7465   Dali::Vector4 *result = 0 ;
7466
7467   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7468   jresult = (void *)result;
7469   return jresult;
7470 }
7471
7472
7473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7474   void * jresult ;
7475   Dali::Vector4 *result = 0 ;
7476
7477   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7478   jresult = (void *)result;
7479   return jresult;
7480 }
7481
7482
7483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7484   void * jresult ;
7485   Dali::Vector4 *result = 0 ;
7486
7487   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7488   jresult = (void *)result;
7489   return jresult;
7490 }
7491
7492
7493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7494   void * jresult ;
7495   Dali::Vector4 *result = 0 ;
7496
7497   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7498   jresult = (void *)result;
7499   return jresult;
7500 }
7501
7502
7503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7504   void * jresult ;
7505   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7506   float *arg2 = (float *) 0 ;
7507   Dali::Vector4 *result = 0 ;
7508
7509   arg1 = (Dali::Vector4 *)jarg1;
7510   arg2 = jarg2;
7511   {
7512     try {
7513       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7514     } catch (std::out_of_range& e) {
7515       {
7516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7517       };
7518     } catch (std::exception& e) {
7519       {
7520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7521       };
7522     } catch (Dali::DaliException e) {
7523       {
7524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7525       };
7526     } catch (...) {
7527       {
7528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7529       };
7530     }
7531   }
7532
7533   jresult = (void *)result;
7534
7535
7536   return jresult;
7537 }
7538
7539
7540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7541   void * jresult ;
7542   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7543   Dali::Vector2 *arg2 = 0 ;
7544   Dali::Vector4 *result = 0 ;
7545
7546   arg1 = (Dali::Vector4 *)jarg1;
7547   arg2 = (Dali::Vector2 *)jarg2;
7548   if (!arg2) {
7549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7550     return 0;
7551   }
7552   {
7553     try {
7554       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7555     } catch (std::out_of_range& e) {
7556       {
7557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7558       };
7559     } catch (std::exception& e) {
7560       {
7561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7562       };
7563     } catch (Dali::DaliException e) {
7564       {
7565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7566       };
7567     } catch (...) {
7568       {
7569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7570       };
7571     }
7572   }
7573
7574   jresult = (void *)result;
7575   return jresult;
7576 }
7577
7578
7579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7580   void * jresult ;
7581   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7582   Dali::Vector3 *arg2 = 0 ;
7583   Dali::Vector4 *result = 0 ;
7584
7585   arg1 = (Dali::Vector4 *)jarg1;
7586   arg2 = (Dali::Vector3 *)jarg2;
7587   if (!arg2) {
7588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7589     return 0;
7590   }
7591   {
7592     try {
7593       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7594     } catch (std::out_of_range& e) {
7595       {
7596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7597       };
7598     } catch (std::exception& e) {
7599       {
7600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7601       };
7602     } catch (Dali::DaliException e) {
7603       {
7604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7605       };
7606     } catch (...) {
7607       {
7608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7609       };
7610     }
7611   }
7612
7613   jresult = (void *)result;
7614   return jresult;
7615 }
7616
7617
7618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7619   void * jresult ;
7620   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7621   Dali::Vector4 *arg2 = 0 ;
7622   Dali::Vector4 result;
7623
7624   arg1 = (Dali::Vector4 *)jarg1;
7625   arg2 = (Dali::Vector4 *)jarg2;
7626   if (!arg2) {
7627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7628     return 0;
7629   }
7630   {
7631     try {
7632       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7633     } catch (std::out_of_range& e) {
7634       {
7635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7636       };
7637     } catch (std::exception& e) {
7638       {
7639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7640       };
7641     } catch (Dali::DaliException e) {
7642       {
7643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7644       };
7645     } catch (...) {
7646       {
7647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7648       };
7649     }
7650   }
7651
7652   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7653   return jresult;
7654 }
7655
7656
7657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7658   void * jresult ;
7659   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7660   Dali::Vector4 *arg2 = 0 ;
7661   Dali::Vector4 *result = 0 ;
7662
7663   arg1 = (Dali::Vector4 *)jarg1;
7664   arg2 = (Dali::Vector4 *)jarg2;
7665   if (!arg2) {
7666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7667     return 0;
7668   }
7669   {
7670     try {
7671       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7672     } catch (std::out_of_range& e) {
7673       {
7674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7675       };
7676     } catch (std::exception& e) {
7677       {
7678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7679       };
7680     } catch (Dali::DaliException e) {
7681       {
7682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7683       };
7684     } catch (...) {
7685       {
7686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7687       };
7688     }
7689   }
7690
7691   jresult = (void *)result;
7692   return jresult;
7693 }
7694
7695
7696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7697   void * jresult ;
7698   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7699   Dali::Vector4 *arg2 = 0 ;
7700   Dali::Vector4 result;
7701
7702   arg1 = (Dali::Vector4 *)jarg1;
7703   arg2 = (Dali::Vector4 *)jarg2;
7704   if (!arg2) {
7705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7706     return 0;
7707   }
7708   {
7709     try {
7710       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7711     } catch (std::out_of_range& e) {
7712       {
7713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7714       };
7715     } catch (std::exception& e) {
7716       {
7717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7718       };
7719     } catch (Dali::DaliException e) {
7720       {
7721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7722       };
7723     } catch (...) {
7724       {
7725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7726       };
7727     }
7728   }
7729
7730   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7731   return jresult;
7732 }
7733
7734
7735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7736   void * jresult ;
7737   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7738   Dali::Vector4 *arg2 = 0 ;
7739   Dali::Vector4 *result = 0 ;
7740
7741   arg1 = (Dali::Vector4 *)jarg1;
7742   arg2 = (Dali::Vector4 *)jarg2;
7743   if (!arg2) {
7744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7745     return 0;
7746   }
7747   {
7748     try {
7749       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7750     } catch (std::out_of_range& e) {
7751       {
7752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7753       };
7754     } catch (std::exception& e) {
7755       {
7756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7757       };
7758     } catch (Dali::DaliException e) {
7759       {
7760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7761       };
7762     } catch (...) {
7763       {
7764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7765       };
7766     }
7767   }
7768
7769   jresult = (void *)result;
7770   return jresult;
7771 }
7772
7773
7774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7775   void * jresult ;
7776   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7777   Dali::Vector4 *arg2 = 0 ;
7778   Dali::Vector4 result;
7779
7780   arg1 = (Dali::Vector4 *)jarg1;
7781   arg2 = (Dali::Vector4 *)jarg2;
7782   if (!arg2) {
7783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7784     return 0;
7785   }
7786   {
7787     try {
7788       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7789     } catch (std::out_of_range& e) {
7790       {
7791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7792       };
7793     } catch (std::exception& e) {
7794       {
7795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7796       };
7797     } catch (Dali::DaliException e) {
7798       {
7799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7800       };
7801     } catch (...) {
7802       {
7803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7804       };
7805     }
7806   }
7807
7808   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7809   return jresult;
7810 }
7811
7812
7813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7814   void * jresult ;
7815   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7816   float arg2 ;
7817   Dali::Vector4 result;
7818
7819   arg1 = (Dali::Vector4 *)jarg1;
7820   arg2 = (float)jarg2;
7821   {
7822     try {
7823       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7824     } catch (std::out_of_range& e) {
7825       {
7826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7827       };
7828     } catch (std::exception& e) {
7829       {
7830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7831       };
7832     } catch (Dali::DaliException e) {
7833       {
7834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7835       };
7836     } catch (...) {
7837       {
7838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7839       };
7840     }
7841   }
7842
7843   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7844   return jresult;
7845 }
7846
7847
7848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7849   void * jresult ;
7850   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7851   Dali::Vector4 *arg2 = 0 ;
7852   Dali::Vector4 *result = 0 ;
7853
7854   arg1 = (Dali::Vector4 *)jarg1;
7855   arg2 = (Dali::Vector4 *)jarg2;
7856   if (!arg2) {
7857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7858     return 0;
7859   }
7860   {
7861     try {
7862       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7863     } catch (std::out_of_range& e) {
7864       {
7865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7866       };
7867     } catch (std::exception& e) {
7868       {
7869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7870       };
7871     } catch (Dali::DaliException e) {
7872       {
7873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7874       };
7875     } catch (...) {
7876       {
7877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7878       };
7879     }
7880   }
7881
7882   jresult = (void *)result;
7883   return jresult;
7884 }
7885
7886
7887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7888   void * jresult ;
7889   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7890   float arg2 ;
7891   Dali::Vector4 *result = 0 ;
7892
7893   arg1 = (Dali::Vector4 *)jarg1;
7894   arg2 = (float)jarg2;
7895   {
7896     try {
7897       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7898     } catch (std::out_of_range& e) {
7899       {
7900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7901       };
7902     } catch (std::exception& e) {
7903       {
7904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7905       };
7906     } catch (Dali::DaliException e) {
7907       {
7908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7909       };
7910     } catch (...) {
7911       {
7912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7913       };
7914     }
7915   }
7916
7917   jresult = (void *)result;
7918   return jresult;
7919 }
7920
7921
7922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7923   void * jresult ;
7924   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7925   Dali::Vector4 *arg2 = 0 ;
7926   Dali::Vector4 result;
7927
7928   arg1 = (Dali::Vector4 *)jarg1;
7929   arg2 = (Dali::Vector4 *)jarg2;
7930   if (!arg2) {
7931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7932     return 0;
7933   }
7934   {
7935     try {
7936       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7937     } catch (std::out_of_range& e) {
7938       {
7939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7940       };
7941     } catch (std::exception& e) {
7942       {
7943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7944       };
7945     } catch (Dali::DaliException e) {
7946       {
7947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7948       };
7949     } catch (...) {
7950       {
7951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7952       };
7953     }
7954   }
7955
7956   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7957   return jresult;
7958 }
7959
7960
7961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7962   void * jresult ;
7963   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7964   float arg2 ;
7965   Dali::Vector4 result;
7966
7967   arg1 = (Dali::Vector4 *)jarg1;
7968   arg2 = (float)jarg2;
7969   {
7970     try {
7971       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7972     } catch (std::out_of_range& e) {
7973       {
7974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7975       };
7976     } catch (std::exception& e) {
7977       {
7978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7979       };
7980     } catch (Dali::DaliException e) {
7981       {
7982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7983       };
7984     } catch (...) {
7985       {
7986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7987       };
7988     }
7989   }
7990
7991   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7992   return jresult;
7993 }
7994
7995
7996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7997   void * jresult ;
7998   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7999   Dali::Vector4 *arg2 = 0 ;
8000   Dali::Vector4 *result = 0 ;
8001
8002   arg1 = (Dali::Vector4 *)jarg1;
8003   arg2 = (Dali::Vector4 *)jarg2;
8004   if (!arg2) {
8005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8006     return 0;
8007   }
8008   {
8009     try {
8010       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
8011     } catch (std::out_of_range& e) {
8012       {
8013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8014       };
8015     } catch (std::exception& e) {
8016       {
8017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8018       };
8019     } catch (Dali::DaliException e) {
8020       {
8021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8022       };
8023     } catch (...) {
8024       {
8025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8026       };
8027     }
8028   }
8029
8030   jresult = (void *)result;
8031   return jresult;
8032 }
8033
8034
8035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8036   void * jresult ;
8037   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8038   float arg2 ;
8039   Dali::Vector4 *result = 0 ;
8040
8041   arg1 = (Dali::Vector4 *)jarg1;
8042   arg2 = (float)jarg2;
8043   {
8044     try {
8045       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8046     } catch (std::out_of_range& e) {
8047       {
8048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8049       };
8050     } catch (std::exception& e) {
8051       {
8052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8053       };
8054     } catch (Dali::DaliException e) {
8055       {
8056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8057       };
8058     } catch (...) {
8059       {
8060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8061       };
8062     }
8063   }
8064
8065   jresult = (void *)result;
8066   return jresult;
8067 }
8068
8069
8070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8071   void * jresult ;
8072   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8073   Dali::Vector4 result;
8074
8075   arg1 = (Dali::Vector4 *)jarg1;
8076   {
8077     try {
8078       result = ((Dali::Vector4 const *)arg1)->operator -();
8079     } catch (std::out_of_range& e) {
8080       {
8081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8082       };
8083     } catch (std::exception& e) {
8084       {
8085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8086       };
8087     } catch (Dali::DaliException e) {
8088       {
8089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8090       };
8091     } catch (...) {
8092       {
8093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8094       };
8095     }
8096   }
8097
8098   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8099   return jresult;
8100 }
8101
8102
8103 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8104   unsigned int jresult ;
8105   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8106   Dali::Vector4 *arg2 = 0 ;
8107   bool result;
8108
8109   arg1 = (Dali::Vector4 *)jarg1;
8110   arg2 = (Dali::Vector4 *)jarg2;
8111   if (!arg2) {
8112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8113     return 0;
8114   }
8115   {
8116     try {
8117       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8118     } catch (std::out_of_range& e) {
8119       {
8120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8121       };
8122     } catch (std::exception& e) {
8123       {
8124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8125       };
8126     } catch (Dali::DaliException e) {
8127       {
8128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8129       };
8130     } catch (...) {
8131       {
8132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8133       };
8134     }
8135   }
8136
8137   jresult = result;
8138   return jresult;
8139 }
8140
8141
8142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8143   unsigned int jresult ;
8144   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8145   Dali::Vector4 *arg2 = 0 ;
8146   bool result;
8147
8148   arg1 = (Dali::Vector4 *)jarg1;
8149   arg2 = (Dali::Vector4 *)jarg2;
8150   if (!arg2) {
8151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8152     return 0;
8153   }
8154   {
8155     try {
8156       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8157     } catch (std::out_of_range& e) {
8158       {
8159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8160       };
8161     } catch (std::exception& e) {
8162       {
8163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8164       };
8165     } catch (Dali::DaliException e) {
8166       {
8167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8168       };
8169     } catch (...) {
8170       {
8171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8172       };
8173     }
8174   }
8175
8176   jresult = result;
8177   return jresult;
8178 }
8179
8180
8181 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8182   float jresult ;
8183   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8184   unsigned int arg2 ;
8185   float *result = 0 ;
8186
8187   arg1 = (Dali::Vector4 *)jarg1;
8188   arg2 = (unsigned int)jarg2;
8189   {
8190     try {
8191       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8192     } catch (std::out_of_range& e) {
8193       {
8194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8195       };
8196     } catch (std::exception& e) {
8197       {
8198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8199       };
8200     } catch (Dali::DaliException e) {
8201       {
8202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8203       };
8204     } catch (...) {
8205       {
8206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8207       };
8208     }
8209   }
8210
8211   jresult = *result;
8212   return jresult;
8213 }
8214
8215
8216 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8217   float jresult ;
8218   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8219   Dali::Vector3 *arg2 = 0 ;
8220   float result;
8221
8222   arg1 = (Dali::Vector4 *)jarg1;
8223   arg2 = (Dali::Vector3 *)jarg2;
8224   if (!arg2) {
8225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8226     return 0;
8227   }
8228   {
8229     try {
8230       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8231     } catch (std::out_of_range& e) {
8232       {
8233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8234       };
8235     } catch (std::exception& e) {
8236       {
8237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8238       };
8239     } catch (Dali::DaliException e) {
8240       {
8241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8242       };
8243     } catch (...) {
8244       {
8245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8246       };
8247     }
8248   }
8249
8250   jresult = result;
8251   return jresult;
8252 }
8253
8254
8255 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8256   float jresult ;
8257   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8258   Dali::Vector4 *arg2 = 0 ;
8259   float result;
8260
8261   arg1 = (Dali::Vector4 *)jarg1;
8262   arg2 = (Dali::Vector4 *)jarg2;
8263   if (!arg2) {
8264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8265     return 0;
8266   }
8267   {
8268     try {
8269       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8270     } catch (std::out_of_range& e) {
8271       {
8272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8273       };
8274     } catch (std::exception& e) {
8275       {
8276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8277       };
8278     } catch (Dali::DaliException e) {
8279       {
8280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8281       };
8282     } catch (...) {
8283       {
8284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8285       };
8286     }
8287   }
8288
8289   jresult = result;
8290   return jresult;
8291 }
8292
8293
8294 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8295   float jresult ;
8296   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8297   Dali::Vector4 *arg2 = 0 ;
8298   float result;
8299
8300   arg1 = (Dali::Vector4 *)jarg1;
8301   arg2 = (Dali::Vector4 *)jarg2;
8302   if (!arg2) {
8303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8304     return 0;
8305   }
8306   {
8307     try {
8308       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8309     } catch (std::out_of_range& e) {
8310       {
8311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8312       };
8313     } catch (std::exception& e) {
8314       {
8315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8316       };
8317     } catch (Dali::DaliException e) {
8318       {
8319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8320       };
8321     } catch (...) {
8322       {
8323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8324       };
8325     }
8326   }
8327
8328   jresult = result;
8329   return jresult;
8330 }
8331
8332
8333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8334   void * jresult ;
8335   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8336   Dali::Vector4 *arg2 = 0 ;
8337   Dali::Vector4 result;
8338
8339   arg1 = (Dali::Vector4 *)jarg1;
8340   arg2 = (Dali::Vector4 *)jarg2;
8341   if (!arg2) {
8342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8343     return 0;
8344   }
8345   {
8346     try {
8347       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8348     } catch (std::out_of_range& e) {
8349       {
8350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8351       };
8352     } catch (std::exception& e) {
8353       {
8354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8355       };
8356     } catch (Dali::DaliException e) {
8357       {
8358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8359       };
8360     } catch (...) {
8361       {
8362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8363       };
8364     }
8365   }
8366
8367   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8368   return jresult;
8369 }
8370
8371
8372 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8373   float jresult ;
8374   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8375   float result;
8376
8377   arg1 = (Dali::Vector4 *)jarg1;
8378   {
8379     try {
8380       result = (float)((Dali::Vector4 const *)arg1)->Length();
8381     } catch (std::out_of_range& e) {
8382       {
8383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8384       };
8385     } catch (std::exception& e) {
8386       {
8387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8388       };
8389     } catch (Dali::DaliException e) {
8390       {
8391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8392       };
8393     } catch (...) {
8394       {
8395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8396       };
8397     }
8398   }
8399
8400   jresult = result;
8401   return jresult;
8402 }
8403
8404
8405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8406   float jresult ;
8407   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8408   float result;
8409
8410   arg1 = (Dali::Vector4 *)jarg1;
8411   {
8412     try {
8413       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8414     } catch (std::out_of_range& e) {
8415       {
8416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8417       };
8418     } catch (std::exception& e) {
8419       {
8420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8421       };
8422     } catch (Dali::DaliException e) {
8423       {
8424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8425       };
8426     } catch (...) {
8427       {
8428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8429       };
8430     }
8431   }
8432
8433   jresult = result;
8434   return jresult;
8435 }
8436
8437
8438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8439   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8440
8441   arg1 = (Dali::Vector4 *)jarg1;
8442   {
8443     try {
8444       (arg1)->Normalize();
8445     } catch (std::out_of_range& e) {
8446       {
8447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8448       };
8449     } catch (std::exception& e) {
8450       {
8451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8452       };
8453     } catch (Dali::DaliException e) {
8454       {
8455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8456       };
8457     } catch (...) {
8458       {
8459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8460       };
8461     }
8462   }
8463
8464 }
8465
8466
8467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8468   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8469   Dali::Vector4 *arg2 = 0 ;
8470   Dali::Vector4 *arg3 = 0 ;
8471
8472   arg1 = (Dali::Vector4 *)jarg1;
8473   arg2 = (Dali::Vector4 *)jarg2;
8474   if (!arg2) {
8475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8476     return ;
8477   }
8478   arg3 = (Dali::Vector4 *)jarg3;
8479   if (!arg3) {
8480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8481     return ;
8482   }
8483   {
8484     try {
8485       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8486     } catch (std::out_of_range& e) {
8487       {
8488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8489       };
8490     } catch (std::exception& e) {
8491       {
8492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8493       };
8494     } catch (Dali::DaliException e) {
8495       {
8496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8497       };
8498     } catch (...) {
8499       {
8500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8501       };
8502     }
8503   }
8504
8505 }
8506
8507
8508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8509   void * jresult ;
8510   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8511   float *result = 0 ;
8512
8513   arg1 = (Dali::Vector4 *)jarg1;
8514   {
8515     try {
8516       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8517     } catch (std::out_of_range& e) {
8518       {
8519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8520       };
8521     } catch (std::exception& e) {
8522       {
8523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8524       };
8525     } catch (Dali::DaliException e) {
8526       {
8527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8528       };
8529     } catch (...) {
8530       {
8531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8532       };
8533     }
8534   }
8535
8536   jresult = (void *)result;
8537   return jresult;
8538 }
8539
8540
8541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8542   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8543   float arg2 ;
8544
8545   arg1 = (Dali::Vector4 *)jarg1;
8546   arg2 = (float)jarg2;
8547   if (arg1) (arg1)->x = arg2;
8548 }
8549
8550
8551 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8552   float jresult ;
8553   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8554   float result;
8555
8556   arg1 = (Dali::Vector4 *)jarg1;
8557   result = (float) ((arg1)->x);
8558   jresult = result;
8559   return jresult;
8560 }
8561
8562
8563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8564   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8565   float arg2 ;
8566
8567   arg1 = (Dali::Vector4 *)jarg1;
8568   arg2 = (float)jarg2;
8569   if (arg1) (arg1)->r = arg2;
8570 }
8571
8572
8573 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8574   float jresult ;
8575   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8576   float result;
8577
8578   arg1 = (Dali::Vector4 *)jarg1;
8579   result = (float) ((arg1)->r);
8580   jresult = result;
8581   return jresult;
8582 }
8583
8584
8585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8586   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8587   float arg2 ;
8588
8589   arg1 = (Dali::Vector4 *)jarg1;
8590   arg2 = (float)jarg2;
8591   if (arg1) (arg1)->s = arg2;
8592 }
8593
8594
8595 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8596   float jresult ;
8597   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8598   float result;
8599
8600   arg1 = (Dali::Vector4 *)jarg1;
8601   result = (float) ((arg1)->s);
8602   jresult = result;
8603   return jresult;
8604 }
8605
8606
8607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8608   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8609   float arg2 ;
8610
8611   arg1 = (Dali::Vector4 *)jarg1;
8612   arg2 = (float)jarg2;
8613   if (arg1) (arg1)->y = arg2;
8614 }
8615
8616
8617 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8618   float jresult ;
8619   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8620   float result;
8621
8622   arg1 = (Dali::Vector4 *)jarg1;
8623   result = (float) ((arg1)->y);
8624   jresult = result;
8625   return jresult;
8626 }
8627
8628
8629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8630   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8631   float arg2 ;
8632
8633   arg1 = (Dali::Vector4 *)jarg1;
8634   arg2 = (float)jarg2;
8635   if (arg1) (arg1)->g = arg2;
8636 }
8637
8638
8639 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8640   float jresult ;
8641   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8642   float result;
8643
8644   arg1 = (Dali::Vector4 *)jarg1;
8645   result = (float) ((arg1)->g);
8646   jresult = result;
8647   return jresult;
8648 }
8649
8650
8651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8652   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8653   float arg2 ;
8654
8655   arg1 = (Dali::Vector4 *)jarg1;
8656   arg2 = (float)jarg2;
8657   if (arg1) (arg1)->t = arg2;
8658 }
8659
8660
8661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8662   float jresult ;
8663   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8664   float result;
8665
8666   arg1 = (Dali::Vector4 *)jarg1;
8667   result = (float) ((arg1)->t);
8668   jresult = result;
8669   return jresult;
8670 }
8671
8672
8673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8674   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8675   float arg2 ;
8676
8677   arg1 = (Dali::Vector4 *)jarg1;
8678   arg2 = (float)jarg2;
8679   if (arg1) (arg1)->z = arg2;
8680 }
8681
8682
8683 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8684   float jresult ;
8685   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8686   float result;
8687
8688   arg1 = (Dali::Vector4 *)jarg1;
8689   result = (float) ((arg1)->z);
8690   jresult = result;
8691   return jresult;
8692 }
8693
8694
8695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8696   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8697   float arg2 ;
8698
8699   arg1 = (Dali::Vector4 *)jarg1;
8700   arg2 = (float)jarg2;
8701   if (arg1) (arg1)->b = arg2;
8702 }
8703
8704
8705 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8706   float jresult ;
8707   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8708   float result;
8709
8710   arg1 = (Dali::Vector4 *)jarg1;
8711   result = (float) ((arg1)->b);
8712   jresult = result;
8713   return jresult;
8714 }
8715
8716
8717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8718   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8719   float arg2 ;
8720
8721   arg1 = (Dali::Vector4 *)jarg1;
8722   arg2 = (float)jarg2;
8723   if (arg1) (arg1)->p = arg2;
8724 }
8725
8726
8727 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8728   float jresult ;
8729   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8730   float result;
8731
8732   arg1 = (Dali::Vector4 *)jarg1;
8733   result = (float) ((arg1)->p);
8734   jresult = result;
8735   return jresult;
8736 }
8737
8738
8739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8740   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8741   float arg2 ;
8742
8743   arg1 = (Dali::Vector4 *)jarg1;
8744   arg2 = (float)jarg2;
8745   if (arg1) (arg1)->w = arg2;
8746 }
8747
8748
8749 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8750   float jresult ;
8751   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8752   float result;
8753
8754   arg1 = (Dali::Vector4 *)jarg1;
8755   result = (float) ((arg1)->w);
8756   jresult = result;
8757   return jresult;
8758 }
8759
8760
8761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8762   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8763   float arg2 ;
8764
8765   arg1 = (Dali::Vector4 *)jarg1;
8766   arg2 = (float)jarg2;
8767   if (arg1) (arg1)->a = arg2;
8768 }
8769
8770
8771 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8772   float jresult ;
8773   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8774   float result;
8775
8776   arg1 = (Dali::Vector4 *)jarg1;
8777   result = (float) ((arg1)->a);
8778   jresult = result;
8779   return jresult;
8780 }
8781
8782
8783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8784   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8785   float arg2 ;
8786
8787   arg1 = (Dali::Vector4 *)jarg1;
8788   arg2 = (float)jarg2;
8789   if (arg1) (arg1)->q = arg2;
8790 }
8791
8792
8793 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8794   float jresult ;
8795   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8796   float result;
8797
8798   arg1 = (Dali::Vector4 *)jarg1;
8799   result = (float) ((arg1)->q);
8800   jresult = result;
8801   return jresult;
8802 }
8803
8804
8805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8806   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8807
8808   arg1 = (Dali::Vector4 *)jarg1;
8809   {
8810     try {
8811       delete arg1;
8812     } catch (std::out_of_range& e) {
8813       {
8814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8815       };
8816     } catch (std::exception& e) {
8817       {
8818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8819       };
8820     } catch (Dali::DaliException e) {
8821       {
8822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8823       };
8824     } catch (...) {
8825       {
8826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8827       };
8828     }
8829   }
8830
8831 }
8832
8833
8834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8835   void * jresult ;
8836   Dali::Vector4 *arg1 = 0 ;
8837   Dali::Vector4 *arg2 = 0 ;
8838   Dali::Vector4 result;
8839
8840   arg1 = (Dali::Vector4 *)jarg1;
8841   if (!arg1) {
8842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8843     return 0;
8844   }
8845   arg2 = (Dali::Vector4 *)jarg2;
8846   if (!arg2) {
8847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8848     return 0;
8849   }
8850   {
8851     try {
8852       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8853     } catch (std::out_of_range& e) {
8854       {
8855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8856       };
8857     } catch (std::exception& e) {
8858       {
8859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8860       };
8861     } catch (Dali::DaliException e) {
8862       {
8863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8864       };
8865     } catch (...) {
8866       {
8867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8868       };
8869     }
8870   }
8871
8872   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8873   return jresult;
8874 }
8875
8876
8877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8878   void * jresult ;
8879   Dali::Vector4 *arg1 = 0 ;
8880   Dali::Vector4 *arg2 = 0 ;
8881   Dali::Vector4 result;
8882
8883   arg1 = (Dali::Vector4 *)jarg1;
8884   if (!arg1) {
8885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8886     return 0;
8887   }
8888   arg2 = (Dali::Vector4 *)jarg2;
8889   if (!arg2) {
8890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8891     return 0;
8892   }
8893   {
8894     try {
8895       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8896     } catch (std::out_of_range& e) {
8897       {
8898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8899       };
8900     } catch (std::exception& e) {
8901       {
8902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8903       };
8904     } catch (Dali::DaliException e) {
8905       {
8906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8907       };
8908     } catch (...) {
8909       {
8910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8911       };
8912     }
8913   }
8914
8915   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8916   return jresult;
8917 }
8918
8919
8920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8921   void * jresult ;
8922   Dali::Vector4 *arg1 = 0 ;
8923   float *arg2 = 0 ;
8924   float *arg3 = 0 ;
8925   float temp2 ;
8926   float temp3 ;
8927   Dali::Vector4 result;
8928
8929   arg1 = (Dali::Vector4 *)jarg1;
8930   if (!arg1) {
8931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8932     return 0;
8933   }
8934   temp2 = (float)jarg2;
8935   arg2 = &temp2;
8936   temp3 = (float)jarg3;
8937   arg3 = &temp3;
8938   {
8939     try {
8940       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8941     } catch (std::out_of_range& e) {
8942       {
8943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8944       };
8945     } catch (std::exception& e) {
8946       {
8947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8948       };
8949     } catch (Dali::DaliException e) {
8950       {
8951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8952       };
8953     } catch (...) {
8954       {
8955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8956       };
8957     }
8958   }
8959
8960   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8961   return jresult;
8962 }
8963
8964
8965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8966   void * jresult ;
8967   Dali::Uint16Pair *result = 0 ;
8968
8969   {
8970     try {
8971       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8972     } catch (std::out_of_range& e) {
8973       {
8974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8975       };
8976     } catch (std::exception& e) {
8977       {
8978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8979       };
8980     } catch (Dali::DaliException e) {
8981       {
8982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8983       };
8984     } catch (...) {
8985       {
8986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8987       };
8988     }
8989   }
8990
8991   jresult = (void *)result;
8992   return jresult;
8993 }
8994
8995
8996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8997   void * jresult ;
8998   uint32_t arg1 ;
8999   uint32_t arg2 ;
9000   Dali::Uint16Pair *result = 0 ;
9001
9002   arg1 = (uint32_t)jarg1;
9003   arg2 = (uint32_t)jarg2;
9004   {
9005     try {
9006       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
9007     } catch (std::out_of_range& e) {
9008       {
9009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9010       };
9011     } catch (std::exception& e) {
9012       {
9013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9014       };
9015     } catch (Dali::DaliException e) {
9016       {
9017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9018       };
9019     } catch (...) {
9020       {
9021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9022       };
9023     }
9024   }
9025
9026   jresult = (void *)result;
9027   return jresult;
9028 }
9029
9030
9031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9032   void * jresult ;
9033   Dali::Uint16Pair *arg1 = 0 ;
9034   Dali::Uint16Pair *result = 0 ;
9035
9036   arg1 = (Dali::Uint16Pair *)jarg1;
9037   if (!arg1) {
9038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9039     return 0;
9040   }
9041   {
9042     try {
9043       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9044     } catch (std::out_of_range& e) {
9045       {
9046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9047       };
9048     } catch (std::exception& e) {
9049       {
9050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9051       };
9052     } catch (Dali::DaliException e) {
9053       {
9054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9055       };
9056     } catch (...) {
9057       {
9058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9059       };
9060     }
9061   }
9062
9063   jresult = (void *)result;
9064   return jresult;
9065 }
9066
9067
9068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9069   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9070   uint16_t arg2 ;
9071
9072   arg1 = (Dali::Uint16Pair *)jarg1;
9073   arg2 = (uint16_t)jarg2;
9074   {
9075     try {
9076       (arg1)->SetWidth(arg2);
9077     } catch (std::out_of_range& e) {
9078       {
9079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9080       };
9081     } catch (std::exception& e) {
9082       {
9083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9084       };
9085     } catch (Dali::DaliException e) {
9086       {
9087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9088       };
9089     } catch (...) {
9090       {
9091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9092       };
9093     }
9094   }
9095
9096 }
9097
9098
9099 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9100   unsigned short jresult ;
9101   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9102   uint16_t result;
9103
9104   arg1 = (Dali::Uint16Pair *)jarg1;
9105   {
9106     try {
9107       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9108     } catch (std::out_of_range& e) {
9109       {
9110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9111       };
9112     } catch (std::exception& e) {
9113       {
9114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9115       };
9116     } catch (Dali::DaliException e) {
9117       {
9118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9119       };
9120     } catch (...) {
9121       {
9122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9123       };
9124     }
9125   }
9126
9127   jresult = result;
9128   return jresult;
9129 }
9130
9131
9132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9133   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9134   uint16_t arg2 ;
9135
9136   arg1 = (Dali::Uint16Pair *)jarg1;
9137   arg2 = (uint16_t)jarg2;
9138   {
9139     try {
9140       (arg1)->SetHeight(arg2);
9141     } catch (std::out_of_range& e) {
9142       {
9143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9144       };
9145     } catch (std::exception& e) {
9146       {
9147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9148       };
9149     } catch (Dali::DaliException e) {
9150       {
9151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9152       };
9153     } catch (...) {
9154       {
9155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9156       };
9157     }
9158   }
9159
9160 }
9161
9162
9163 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9164   unsigned short jresult ;
9165   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9166   uint16_t result;
9167
9168   arg1 = (Dali::Uint16Pair *)jarg1;
9169   {
9170     try {
9171       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9172     } catch (std::out_of_range& e) {
9173       {
9174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9175       };
9176     } catch (std::exception& e) {
9177       {
9178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9179       };
9180     } catch (Dali::DaliException e) {
9181       {
9182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9183       };
9184     } catch (...) {
9185       {
9186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9187       };
9188     }
9189   }
9190
9191   jresult = result;
9192   return jresult;
9193 }
9194
9195
9196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9197   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9198   uint16_t arg2 ;
9199
9200   arg1 = (Dali::Uint16Pair *)jarg1;
9201   arg2 = (uint16_t)jarg2;
9202   {
9203     try {
9204       (arg1)->SetX(arg2);
9205     } catch (std::out_of_range& e) {
9206       {
9207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9208       };
9209     } catch (std::exception& e) {
9210       {
9211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9212       };
9213     } catch (Dali::DaliException e) {
9214       {
9215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9216       };
9217     } catch (...) {
9218       {
9219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9220       };
9221     }
9222   }
9223
9224 }
9225
9226
9227 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9228   unsigned short jresult ;
9229   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9230   uint16_t result;
9231
9232   arg1 = (Dali::Uint16Pair *)jarg1;
9233   {
9234     try {
9235       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9236     } catch (std::out_of_range& e) {
9237       {
9238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9239       };
9240     } catch (std::exception& e) {
9241       {
9242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9243       };
9244     } catch (Dali::DaliException e) {
9245       {
9246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9247       };
9248     } catch (...) {
9249       {
9250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9251       };
9252     }
9253   }
9254
9255   jresult = result;
9256   return jresult;
9257 }
9258
9259
9260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9261   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9262   uint16_t arg2 ;
9263
9264   arg1 = (Dali::Uint16Pair *)jarg1;
9265   arg2 = (uint16_t)jarg2;
9266   {
9267     try {
9268       (arg1)->SetY(arg2);
9269     } catch (std::out_of_range& e) {
9270       {
9271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9272       };
9273     } catch (std::exception& e) {
9274       {
9275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9276       };
9277     } catch (Dali::DaliException e) {
9278       {
9279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9280       };
9281     } catch (...) {
9282       {
9283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9284       };
9285     }
9286   }
9287
9288 }
9289
9290
9291 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9292   unsigned short jresult ;
9293   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9294   uint16_t result;
9295
9296   arg1 = (Dali::Uint16Pair *)jarg1;
9297   {
9298     try {
9299       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9300     } catch (std::out_of_range& e) {
9301       {
9302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9303       };
9304     } catch (std::exception& e) {
9305       {
9306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9307       };
9308     } catch (Dali::DaliException e) {
9309       {
9310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9311       };
9312     } catch (...) {
9313       {
9314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9315       };
9316     }
9317   }
9318
9319   jresult = result;
9320   return jresult;
9321 }
9322
9323
9324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9325   void * jresult ;
9326   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9327   Dali::Uint16Pair *arg2 = 0 ;
9328   Dali::Uint16Pair *result = 0 ;
9329
9330   arg1 = (Dali::Uint16Pair *)jarg1;
9331   arg2 = (Dali::Uint16Pair *)jarg2;
9332   if (!arg2) {
9333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9334     return 0;
9335   }
9336   {
9337     try {
9338       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9339     } catch (std::out_of_range& e) {
9340       {
9341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9342       };
9343     } catch (std::exception& e) {
9344       {
9345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9346       };
9347     } catch (Dali::DaliException e) {
9348       {
9349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9350       };
9351     } catch (...) {
9352       {
9353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9354       };
9355     }
9356   }
9357
9358   jresult = (void *)result;
9359   return jresult;
9360 }
9361
9362
9363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9364   unsigned int jresult ;
9365   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9366   Dali::Uint16Pair *arg2 = 0 ;
9367   bool result;
9368
9369   arg1 = (Dali::Uint16Pair *)jarg1;
9370   arg2 = (Dali::Uint16Pair *)jarg2;
9371   if (!arg2) {
9372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9373     return 0;
9374   }
9375   {
9376     try {
9377       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9378     } catch (std::out_of_range& e) {
9379       {
9380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9381       };
9382     } catch (std::exception& e) {
9383       {
9384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9385       };
9386     } catch (Dali::DaliException e) {
9387       {
9388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9389       };
9390     } catch (...) {
9391       {
9392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9393       };
9394     }
9395   }
9396
9397   jresult = result;
9398   return jresult;
9399 }
9400
9401
9402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9403   unsigned int jresult ;
9404   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9405   Dali::Uint16Pair *arg2 = 0 ;
9406   bool result;
9407
9408   arg1 = (Dali::Uint16Pair *)jarg1;
9409   arg2 = (Dali::Uint16Pair *)jarg2;
9410   if (!arg2) {
9411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9412     return 0;
9413   }
9414   {
9415     try {
9416       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9417     } catch (std::out_of_range& e) {
9418       {
9419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9420       };
9421     } catch (std::exception& e) {
9422       {
9423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9424       };
9425     } catch (Dali::DaliException e) {
9426       {
9427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9428       };
9429     } catch (...) {
9430       {
9431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9432       };
9433     }
9434   }
9435
9436   jresult = result;
9437   return jresult;
9438 }
9439
9440
9441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9442   unsigned int jresult ;
9443   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9444   Dali::Uint16Pair *arg2 = 0 ;
9445   bool result;
9446
9447   arg1 = (Dali::Uint16Pair *)jarg1;
9448   arg2 = (Dali::Uint16Pair *)jarg2;
9449   if (!arg2) {
9450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9451     return 0;
9452   }
9453   {
9454     try {
9455       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9456     } catch (std::out_of_range& e) {
9457       {
9458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9459       };
9460     } catch (std::exception& e) {
9461       {
9462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9463       };
9464     } catch (Dali::DaliException e) {
9465       {
9466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9467       };
9468     } catch (...) {
9469       {
9470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9471       };
9472     }
9473   }
9474
9475   jresult = result;
9476   return jresult;
9477 }
9478
9479
9480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9481   unsigned int jresult ;
9482   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9483   Dali::Uint16Pair *arg2 = 0 ;
9484   bool result;
9485
9486   arg1 = (Dali::Uint16Pair *)jarg1;
9487   arg2 = (Dali::Uint16Pair *)jarg2;
9488   if (!arg2) {
9489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9490     return 0;
9491   }
9492   {
9493     try {
9494       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9495     } catch (std::out_of_range& e) {
9496       {
9497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9498       };
9499     } catch (std::exception& e) {
9500       {
9501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9502       };
9503     } catch (Dali::DaliException e) {
9504       {
9505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9506       };
9507     } catch (...) {
9508       {
9509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9510       };
9511     }
9512   }
9513
9514   jresult = result;
9515   return jresult;
9516 }
9517
9518
9519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9520   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9521
9522   arg1 = (Dali::Uint16Pair *)jarg1;
9523   {
9524     try {
9525       delete arg1;
9526     } catch (std::out_of_range& e) {
9527       {
9528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9529       };
9530     } catch (std::exception& e) {
9531       {
9532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9533       };
9534     } catch (Dali::DaliException e) {
9535       {
9536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9537       };
9538     } catch (...) {
9539       {
9540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9541       };
9542     }
9543   }
9544
9545 }
9546
9547
9548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9549   void * jresult ;
9550   Dali::Degree *result = 0 ;
9551
9552   {
9553     try {
9554       result = (Dali::Degree *)new Dali::Degree();
9555     } catch (std::out_of_range& e) {
9556       {
9557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9558       };
9559     } catch (std::exception& e) {
9560       {
9561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9562       };
9563     } catch (Dali::DaliException e) {
9564       {
9565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9566       };
9567     } catch (...) {
9568       {
9569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9570       };
9571     }
9572   }
9573
9574   jresult = (void *)result;
9575   return jresult;
9576 }
9577
9578
9579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9580   void * jresult ;
9581   float arg1 ;
9582   Dali::Degree *result = 0 ;
9583
9584   arg1 = (float)jarg1;
9585   {
9586     try {
9587       result = (Dali::Degree *)new Dali::Degree(arg1);
9588     } catch (std::out_of_range& e) {
9589       {
9590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9591       };
9592     } catch (std::exception& e) {
9593       {
9594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9595       };
9596     } catch (Dali::DaliException e) {
9597       {
9598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9599       };
9600     } catch (...) {
9601       {
9602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9603       };
9604     }
9605   }
9606
9607   jresult = (void *)result;
9608   return jresult;
9609 }
9610
9611
9612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9613   void * jresult ;
9614   Dali::Radian arg1 ;
9615   Dali::Radian *argp1 ;
9616   Dali::Degree *result = 0 ;
9617
9618   argp1 = (Dali::Radian *)jarg1;
9619   if (!argp1) {
9620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9621     return 0;
9622   }
9623   arg1 = *argp1;
9624   {
9625     try {
9626       result = (Dali::Degree *)new Dali::Degree(arg1);
9627     } catch (std::out_of_range& e) {
9628       {
9629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9630       };
9631     } catch (std::exception& e) {
9632       {
9633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9634       };
9635     } catch (Dali::DaliException e) {
9636       {
9637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9638       };
9639     } catch (...) {
9640       {
9641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9642       };
9643     }
9644   }
9645
9646   jresult = (void *)result;
9647   return jresult;
9648 }
9649
9650
9651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9652   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9653   float arg2 ;
9654
9655   arg1 = (Dali::Degree *)jarg1;
9656   arg2 = (float)jarg2;
9657   if (arg1) (arg1)->degree = arg2;
9658 }
9659
9660
9661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9662   float jresult ;
9663   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9664   float result;
9665
9666   arg1 = (Dali::Degree *)jarg1;
9667   result = (float) ((arg1)->degree);
9668   jresult = result;
9669   return jresult;
9670 }
9671
9672
9673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9674   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9675
9676   arg1 = (Dali::Degree *)jarg1;
9677   {
9678     try {
9679       delete arg1;
9680     } catch (std::out_of_range& e) {
9681       {
9682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9683       };
9684     } catch (std::exception& e) {
9685       {
9686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9687       };
9688     } catch (Dali::DaliException e) {
9689       {
9690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9691       };
9692     } catch (...) {
9693       {
9694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9695       };
9696     }
9697   }
9698
9699 }
9700
9701
9702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9703   void * jresult ;
9704   Dali::Radian *result = 0 ;
9705
9706   result = (Dali::Radian *)&Dali::ANGLE_360;
9707   jresult = (void *)result;
9708   return jresult;
9709 }
9710
9711
9712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9713   void * jresult ;
9714   Dali::Radian *result = 0 ;
9715
9716   result = (Dali::Radian *)&Dali::ANGLE_315;
9717   jresult = (void *)result;
9718   return jresult;
9719 }
9720
9721
9722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9723   void * jresult ;
9724   Dali::Radian *result = 0 ;
9725
9726   result = (Dali::Radian *)&Dali::ANGLE_270;
9727   jresult = (void *)result;
9728   return jresult;
9729 }
9730
9731
9732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9733   void * jresult ;
9734   Dali::Radian *result = 0 ;
9735
9736   result = (Dali::Radian *)&Dali::ANGLE_225;
9737   jresult = (void *)result;
9738   return jresult;
9739 }
9740
9741
9742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9743   void * jresult ;
9744   Dali::Radian *result = 0 ;
9745
9746   result = (Dali::Radian *)&Dali::ANGLE_180;
9747   jresult = (void *)result;
9748   return jresult;
9749 }
9750
9751
9752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9753   void * jresult ;
9754   Dali::Radian *result = 0 ;
9755
9756   result = (Dali::Radian *)&Dali::ANGLE_135;
9757   jresult = (void *)result;
9758   return jresult;
9759 }
9760
9761
9762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9763   void * jresult ;
9764   Dali::Radian *result = 0 ;
9765
9766   result = (Dali::Radian *)&Dali::ANGLE_120;
9767   jresult = (void *)result;
9768   return jresult;
9769 }
9770
9771
9772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9773   void * jresult ;
9774   Dali::Radian *result = 0 ;
9775
9776   result = (Dali::Radian *)&Dali::ANGLE_90;
9777   jresult = (void *)result;
9778   return jresult;
9779 }
9780
9781
9782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9783   void * jresult ;
9784   Dali::Radian *result = 0 ;
9785
9786   result = (Dali::Radian *)&Dali::ANGLE_60;
9787   jresult = (void *)result;
9788   return jresult;
9789 }
9790
9791
9792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9793   void * jresult ;
9794   Dali::Radian *result = 0 ;
9795
9796   result = (Dali::Radian *)&Dali::ANGLE_45;
9797   jresult = (void *)result;
9798   return jresult;
9799 }
9800
9801
9802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9803   void * jresult ;
9804   Dali::Radian *result = 0 ;
9805
9806   result = (Dali::Radian *)&Dali::ANGLE_30;
9807   jresult = (void *)result;
9808   return jresult;
9809 }
9810
9811
9812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9813   void * jresult ;
9814   Dali::Radian *result = 0 ;
9815
9816   result = (Dali::Radian *)&Dali::ANGLE_0;
9817   jresult = (void *)result;
9818   return jresult;
9819 }
9820
9821
9822 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9823   unsigned int jresult ;
9824   Dali::Degree *arg1 = 0 ;
9825   Dali::Degree *arg2 = 0 ;
9826   bool result;
9827
9828   arg1 = (Dali::Degree *)jarg1;
9829   if (!arg1) {
9830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9831     return 0;
9832   }
9833   arg2 = (Dali::Degree *)jarg2;
9834   if (!arg2) {
9835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9836     return 0;
9837   }
9838   {
9839     try {
9840       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9841     } catch (std::out_of_range& e) {
9842       {
9843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9844       };
9845     } catch (std::exception& e) {
9846       {
9847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9848       };
9849     } catch (Dali::DaliException e) {
9850       {
9851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9852       };
9853     } catch (...) {
9854       {
9855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9856       };
9857     }
9858   }
9859
9860   jresult = result;
9861   return jresult;
9862 }
9863
9864
9865 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9866   unsigned int jresult ;
9867   Dali::Degree *arg1 = 0 ;
9868   Dali::Degree *arg2 = 0 ;
9869   bool result;
9870
9871   arg1 = (Dali::Degree *)jarg1;
9872   if (!arg1) {
9873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9874     return 0;
9875   }
9876   arg2 = (Dali::Degree *)jarg2;
9877   if (!arg2) {
9878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9879     return 0;
9880   }
9881   {
9882     try {
9883       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9884     } catch (std::out_of_range& e) {
9885       {
9886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9887       };
9888     } catch (std::exception& e) {
9889       {
9890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9891       };
9892     } catch (Dali::DaliException e) {
9893       {
9894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9895       };
9896     } catch (...) {
9897       {
9898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9899       };
9900     }
9901   }
9902
9903   jresult = result;
9904   return jresult;
9905 }
9906
9907
9908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9909   void * jresult ;
9910   Dali::Degree arg1 ;
9911   float arg2 ;
9912   float arg3 ;
9913   Dali::Degree *argp1 ;
9914   Dali::Degree result;
9915
9916   argp1 = (Dali::Degree *)jarg1;
9917   if (!argp1) {
9918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9919     return 0;
9920   }
9921   arg1 = *argp1;
9922   arg2 = (float)jarg2;
9923   arg3 = (float)jarg3;
9924   {
9925     try {
9926       result = Dali::Clamp(arg1,arg2,arg3);
9927     } catch (std::out_of_range& e) {
9928       {
9929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9930       };
9931     } catch (std::exception& e) {
9932       {
9933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9934       };
9935     } catch (Dali::DaliException e) {
9936       {
9937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9938       };
9939     } catch (...) {
9940       {
9941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9942       };
9943     }
9944   }
9945
9946   jresult = new Dali::Degree((const Dali::Degree &)result);
9947   return jresult;
9948 }
9949
9950
9951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9952   void * jresult ;
9953   Dali::Radian *result = 0 ;
9954
9955   {
9956     try {
9957       result = (Dali::Radian *)new Dali::Radian();
9958     } catch (std::out_of_range& e) {
9959       {
9960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9961       };
9962     } catch (std::exception& e) {
9963       {
9964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9965       };
9966     } catch (Dali::DaliException e) {
9967       {
9968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9969       };
9970     } catch (...) {
9971       {
9972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9973       };
9974     }
9975   }
9976
9977   jresult = (void *)result;
9978   return jresult;
9979 }
9980
9981
9982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9983   void * jresult ;
9984   float arg1 ;
9985   Dali::Radian *result = 0 ;
9986
9987   arg1 = (float)jarg1;
9988   {
9989     try {
9990       result = (Dali::Radian *)new Dali::Radian(arg1);
9991     } catch (std::out_of_range& e) {
9992       {
9993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9994       };
9995     } catch (std::exception& e) {
9996       {
9997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9998       };
9999     } catch (Dali::DaliException e) {
10000       {
10001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10002       };
10003     } catch (...) {
10004       {
10005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10006       };
10007     }
10008   }
10009
10010   jresult = (void *)result;
10011   return jresult;
10012 }
10013
10014
10015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
10016   void * jresult ;
10017   Dali::Degree arg1 ;
10018   Dali::Degree *argp1 ;
10019   Dali::Radian *result = 0 ;
10020
10021   argp1 = (Dali::Degree *)jarg1;
10022   if (!argp1) {
10023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10024     return 0;
10025   }
10026   arg1 = *argp1;
10027   {
10028     try {
10029       result = (Dali::Radian *)new Dali::Radian(arg1);
10030     } catch (std::out_of_range& e) {
10031       {
10032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10033       };
10034     } catch (std::exception& e) {
10035       {
10036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10037       };
10038     } catch (Dali::DaliException e) {
10039       {
10040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10041       };
10042     } catch (...) {
10043       {
10044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10045       };
10046     }
10047   }
10048
10049   jresult = (void *)result;
10050   return jresult;
10051 }
10052
10053
10054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10055   void * jresult ;
10056   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10057   float arg2 ;
10058   Dali::Radian *result = 0 ;
10059
10060   arg1 = (Dali::Radian *)jarg1;
10061   arg2 = (float)jarg2;
10062   {
10063     try {
10064       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10065     } catch (std::out_of_range& e) {
10066       {
10067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10068       };
10069     } catch (std::exception& e) {
10070       {
10071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10072       };
10073     } catch (Dali::DaliException e) {
10074       {
10075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10076       };
10077     } catch (...) {
10078       {
10079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10080       };
10081     }
10082   }
10083
10084   jresult = (void *)result;
10085   return jresult;
10086 }
10087
10088
10089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10090   void * jresult ;
10091   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10092   Dali::Degree arg2 ;
10093   Dali::Degree *argp2 ;
10094   Dali::Radian *result = 0 ;
10095
10096   arg1 = (Dali::Radian *)jarg1;
10097   argp2 = (Dali::Degree *)jarg2;
10098   if (!argp2) {
10099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10100     return 0;
10101   }
10102   arg2 = *argp2;
10103   {
10104     try {
10105       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10106     } catch (std::out_of_range& e) {
10107       {
10108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10109       };
10110     } catch (std::exception& e) {
10111       {
10112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10113       };
10114     } catch (Dali::DaliException e) {
10115       {
10116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10117       };
10118     } catch (...) {
10119       {
10120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10121       };
10122     }
10123   }
10124
10125   jresult = (void *)result;
10126   return jresult;
10127 }
10128
10129
10130 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10131   float jresult ;
10132   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10133   float result;
10134
10135   arg1 = (Dali::Radian *)jarg1;
10136   {
10137     try {
10138       result = (float)((Dali::Radian const *)arg1)->operator float();
10139     } catch (std::out_of_range& e) {
10140       {
10141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10142       };
10143     } catch (std::exception& e) {
10144       {
10145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10146       };
10147     } catch (Dali::DaliException e) {
10148       {
10149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10150       };
10151     } catch (...) {
10152       {
10153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10154       };
10155     }
10156   }
10157
10158   jresult = result;
10159   return jresult;
10160 }
10161
10162
10163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10164   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10165   float arg2 ;
10166
10167   arg1 = (Dali::Radian *)jarg1;
10168   arg2 = (float)jarg2;
10169   if (arg1) (arg1)->radian = arg2;
10170 }
10171
10172
10173 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10174   float jresult ;
10175   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10176   float result;
10177
10178   arg1 = (Dali::Radian *)jarg1;
10179   result = (float) ((arg1)->radian);
10180   jresult = result;
10181   return jresult;
10182 }
10183
10184
10185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10186   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10187
10188   arg1 = (Dali::Radian *)jarg1;
10189   {
10190     try {
10191       delete arg1;
10192     } catch (std::out_of_range& e) {
10193       {
10194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10195       };
10196     } catch (std::exception& e) {
10197       {
10198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10199       };
10200     } catch (Dali::DaliException e) {
10201       {
10202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10203       };
10204     } catch (...) {
10205       {
10206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10207       };
10208     }
10209   }
10210
10211 }
10212
10213
10214 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10215   unsigned int jresult ;
10216   Dali::Radian arg1 ;
10217   Dali::Radian arg2 ;
10218   Dali::Radian *argp1 ;
10219   Dali::Radian *argp2 ;
10220   bool result;
10221
10222   argp1 = (Dali::Radian *)jarg1;
10223   if (!argp1) {
10224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10225     return 0;
10226   }
10227   arg1 = *argp1;
10228   argp2 = (Dali::Radian *)jarg2;
10229   if (!argp2) {
10230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10231     return 0;
10232   }
10233   arg2 = *argp2;
10234   {
10235     try {
10236       result = (bool)Dali::operator ==(arg1,arg2);
10237     } catch (std::out_of_range& e) {
10238       {
10239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10240       };
10241     } catch (std::exception& e) {
10242       {
10243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10244       };
10245     } catch (Dali::DaliException e) {
10246       {
10247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10248       };
10249     } catch (...) {
10250       {
10251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10252       };
10253     }
10254   }
10255
10256   jresult = result;
10257   return jresult;
10258 }
10259
10260
10261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10262   unsigned int jresult ;
10263   Dali::Radian arg1 ;
10264   Dali::Radian arg2 ;
10265   Dali::Radian *argp1 ;
10266   Dali::Radian *argp2 ;
10267   bool result;
10268
10269   argp1 = (Dali::Radian *)jarg1;
10270   if (!argp1) {
10271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10272     return 0;
10273   }
10274   arg1 = *argp1;
10275   argp2 = (Dali::Radian *)jarg2;
10276   if (!argp2) {
10277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10278     return 0;
10279   }
10280   arg2 = *argp2;
10281   {
10282     try {
10283       result = (bool)Dali::operator !=(arg1,arg2);
10284     } catch (std::out_of_range& e) {
10285       {
10286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10287       };
10288     } catch (std::exception& e) {
10289       {
10290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10291       };
10292     } catch (Dali::DaliException e) {
10293       {
10294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10295       };
10296     } catch (...) {
10297       {
10298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10299       };
10300     }
10301   }
10302
10303   jresult = result;
10304   return jresult;
10305 }
10306
10307
10308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10309   unsigned int jresult ;
10310   Dali::Radian arg1 ;
10311   Dali::Degree arg2 ;
10312   Dali::Radian *argp1 ;
10313   Dali::Degree *argp2 ;
10314   bool result;
10315
10316   argp1 = (Dali::Radian *)jarg1;
10317   if (!argp1) {
10318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10319     return 0;
10320   }
10321   arg1 = *argp1;
10322   argp2 = (Dali::Degree *)jarg2;
10323   if (!argp2) {
10324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10325     return 0;
10326   }
10327   arg2 = *argp2;
10328   {
10329     try {
10330       result = (bool)Dali::operator ==(arg1,arg2);
10331     } catch (std::out_of_range& e) {
10332       {
10333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10334       };
10335     } catch (std::exception& e) {
10336       {
10337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10338       };
10339     } catch (Dali::DaliException e) {
10340       {
10341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10342       };
10343     } catch (...) {
10344       {
10345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10346       };
10347     }
10348   }
10349
10350   jresult = result;
10351   return jresult;
10352 }
10353
10354
10355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10356   unsigned int jresult ;
10357   Dali::Radian arg1 ;
10358   Dali::Degree arg2 ;
10359   Dali::Radian *argp1 ;
10360   Dali::Degree *argp2 ;
10361   bool result;
10362
10363   argp1 = (Dali::Radian *)jarg1;
10364   if (!argp1) {
10365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10366     return 0;
10367   }
10368   arg1 = *argp1;
10369   argp2 = (Dali::Degree *)jarg2;
10370   if (!argp2) {
10371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10372     return 0;
10373   }
10374   arg2 = *argp2;
10375   {
10376     try {
10377       result = (bool)Dali::operator !=(arg1,arg2);
10378     } catch (std::out_of_range& e) {
10379       {
10380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10381       };
10382     } catch (std::exception& e) {
10383       {
10384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10385       };
10386     } catch (Dali::DaliException e) {
10387       {
10388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10389       };
10390     } catch (...) {
10391       {
10392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10393       };
10394     }
10395   }
10396
10397   jresult = result;
10398   return jresult;
10399 }
10400
10401
10402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10403   unsigned int jresult ;
10404   Dali::Degree arg1 ;
10405   Dali::Radian arg2 ;
10406   Dali::Degree *argp1 ;
10407   Dali::Radian *argp2 ;
10408   bool result;
10409
10410   argp1 = (Dali::Degree *)jarg1;
10411   if (!argp1) {
10412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10413     return 0;
10414   }
10415   arg1 = *argp1;
10416   argp2 = (Dali::Radian *)jarg2;
10417   if (!argp2) {
10418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10419     return 0;
10420   }
10421   arg2 = *argp2;
10422   {
10423     try {
10424       result = (bool)Dali::operator ==(arg1,arg2);
10425     } catch (std::out_of_range& e) {
10426       {
10427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10428       };
10429     } catch (std::exception& e) {
10430       {
10431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10432       };
10433     } catch (Dali::DaliException e) {
10434       {
10435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10436       };
10437     } catch (...) {
10438       {
10439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10440       };
10441     }
10442   }
10443
10444   jresult = result;
10445   return jresult;
10446 }
10447
10448
10449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10450   unsigned int jresult ;
10451   Dali::Degree arg1 ;
10452   Dali::Radian arg2 ;
10453   Dali::Degree *argp1 ;
10454   Dali::Radian *argp2 ;
10455   bool result;
10456
10457   argp1 = (Dali::Degree *)jarg1;
10458   if (!argp1) {
10459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10460     return 0;
10461   }
10462   arg1 = *argp1;
10463   argp2 = (Dali::Radian *)jarg2;
10464   if (!argp2) {
10465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10466     return 0;
10467   }
10468   arg2 = *argp2;
10469   {
10470     try {
10471       result = (bool)Dali::operator !=(arg1,arg2);
10472     } catch (std::out_of_range& e) {
10473       {
10474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10475       };
10476     } catch (std::exception& e) {
10477       {
10478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10479       };
10480     } catch (Dali::DaliException e) {
10481       {
10482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10483       };
10484     } catch (...) {
10485       {
10486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10487       };
10488     }
10489   }
10490
10491   jresult = result;
10492   return jresult;
10493 }
10494
10495
10496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10497   unsigned int jresult ;
10498   Dali::Radian arg1 ;
10499   Dali::Radian arg2 ;
10500   Dali::Radian *argp1 ;
10501   Dali::Radian *argp2 ;
10502   bool result;
10503
10504   argp1 = (Dali::Radian *)jarg1;
10505   if (!argp1) {
10506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10507     return 0;
10508   }
10509   arg1 = *argp1;
10510   argp2 = (Dali::Radian *)jarg2;
10511   if (!argp2) {
10512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10513     return 0;
10514   }
10515   arg2 = *argp2;
10516   {
10517     try {
10518       result = (bool)Dali::operator >(arg1,arg2);
10519     } catch (std::out_of_range& e) {
10520       {
10521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10522       };
10523     } catch (std::exception& e) {
10524       {
10525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10526       };
10527     } catch (Dali::DaliException e) {
10528       {
10529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10530       };
10531     } catch (...) {
10532       {
10533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10534       };
10535     }
10536   }
10537
10538   jresult = result;
10539   return jresult;
10540 }
10541
10542
10543 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10544   unsigned int jresult ;
10545   Dali::Radian arg1 ;
10546   Dali::Degree arg2 ;
10547   Dali::Radian *argp1 ;
10548   Dali::Degree *argp2 ;
10549   bool result;
10550
10551   argp1 = (Dali::Radian *)jarg1;
10552   if (!argp1) {
10553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10554     return 0;
10555   }
10556   arg1 = *argp1;
10557   argp2 = (Dali::Degree *)jarg2;
10558   if (!argp2) {
10559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10560     return 0;
10561   }
10562   arg2 = *argp2;
10563   {
10564     try {
10565       result = (bool)Dali::operator >(arg1,arg2);
10566     } catch (std::out_of_range& e) {
10567       {
10568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10569       };
10570     } catch (std::exception& e) {
10571       {
10572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10573       };
10574     } catch (Dali::DaliException e) {
10575       {
10576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10577       };
10578     } catch (...) {
10579       {
10580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10581       };
10582     }
10583   }
10584
10585   jresult = result;
10586   return jresult;
10587 }
10588
10589
10590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10591   unsigned int jresult ;
10592   Dali::Degree arg1 ;
10593   Dali::Radian arg2 ;
10594   Dali::Degree *argp1 ;
10595   Dali::Radian *argp2 ;
10596   bool result;
10597
10598   argp1 = (Dali::Degree *)jarg1;
10599   if (!argp1) {
10600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10601     return 0;
10602   }
10603   arg1 = *argp1;
10604   argp2 = (Dali::Radian *)jarg2;
10605   if (!argp2) {
10606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10607     return 0;
10608   }
10609   arg2 = *argp2;
10610   {
10611     try {
10612       result = (bool)Dali::operator >(arg1,arg2);
10613     } catch (std::out_of_range& e) {
10614       {
10615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10616       };
10617     } catch (std::exception& e) {
10618       {
10619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10620       };
10621     } catch (Dali::DaliException e) {
10622       {
10623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10624       };
10625     } catch (...) {
10626       {
10627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10628       };
10629     }
10630   }
10631
10632   jresult = result;
10633   return jresult;
10634 }
10635
10636
10637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10638   unsigned int jresult ;
10639   Dali::Radian arg1 ;
10640   Dali::Radian arg2 ;
10641   Dali::Radian *argp1 ;
10642   Dali::Radian *argp2 ;
10643   bool result;
10644
10645   argp1 = (Dali::Radian *)jarg1;
10646   if (!argp1) {
10647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10648     return 0;
10649   }
10650   arg1 = *argp1;
10651   argp2 = (Dali::Radian *)jarg2;
10652   if (!argp2) {
10653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10654     return 0;
10655   }
10656   arg2 = *argp2;
10657   {
10658     try {
10659       result = (bool)Dali::operator <(arg1,arg2);
10660     } catch (std::out_of_range& e) {
10661       {
10662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10663       };
10664     } catch (std::exception& e) {
10665       {
10666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10667       };
10668     } catch (Dali::DaliException e) {
10669       {
10670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10671       };
10672     } catch (...) {
10673       {
10674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10675       };
10676     }
10677   }
10678
10679   jresult = result;
10680   return jresult;
10681 }
10682
10683
10684 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10685   unsigned int jresult ;
10686   Dali::Radian arg1 ;
10687   Dali::Degree arg2 ;
10688   Dali::Radian *argp1 ;
10689   Dali::Degree *argp2 ;
10690   bool result;
10691
10692   argp1 = (Dali::Radian *)jarg1;
10693   if (!argp1) {
10694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10695     return 0;
10696   }
10697   arg1 = *argp1;
10698   argp2 = (Dali::Degree *)jarg2;
10699   if (!argp2) {
10700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10701     return 0;
10702   }
10703   arg2 = *argp2;
10704   {
10705     try {
10706       result = (bool)Dali::operator <(arg1,arg2);
10707     } catch (std::out_of_range& e) {
10708       {
10709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10710       };
10711     } catch (std::exception& e) {
10712       {
10713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10714       };
10715     } catch (Dali::DaliException e) {
10716       {
10717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10718       };
10719     } catch (...) {
10720       {
10721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10722       };
10723     }
10724   }
10725
10726   jresult = result;
10727   return jresult;
10728 }
10729
10730
10731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10732   unsigned int jresult ;
10733   Dali::Degree arg1 ;
10734   Dali::Radian arg2 ;
10735   Dali::Degree *argp1 ;
10736   Dali::Radian *argp2 ;
10737   bool result;
10738
10739   argp1 = (Dali::Degree *)jarg1;
10740   if (!argp1) {
10741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10742     return 0;
10743   }
10744   arg1 = *argp1;
10745   argp2 = (Dali::Radian *)jarg2;
10746   if (!argp2) {
10747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10748     return 0;
10749   }
10750   arg2 = *argp2;
10751   {
10752     try {
10753       result = (bool)Dali::operator <(arg1,arg2);
10754     } catch (std::out_of_range& e) {
10755       {
10756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10757       };
10758     } catch (std::exception& e) {
10759       {
10760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10761       };
10762     } catch (Dali::DaliException e) {
10763       {
10764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10765       };
10766     } catch (...) {
10767       {
10768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10769       };
10770     }
10771   }
10772
10773   jresult = result;
10774   return jresult;
10775 }
10776
10777
10778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10779   void * jresult ;
10780   Dali::Radian arg1 ;
10781   float arg2 ;
10782   Dali::Radian *argp1 ;
10783   Dali::Radian result;
10784
10785   argp1 = (Dali::Radian *)jarg1;
10786   if (!argp1) {
10787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10788     return 0;
10789   }
10790   arg1 = *argp1;
10791   arg2 = (float)jarg2;
10792   {
10793     try {
10794       result = Dali::operator *(arg1,arg2);
10795     } catch (std::out_of_range& e) {
10796       {
10797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10798       };
10799     } catch (std::exception& e) {
10800       {
10801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10802       };
10803     } catch (Dali::DaliException e) {
10804       {
10805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10806       };
10807     } catch (...) {
10808       {
10809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10810       };
10811     }
10812   }
10813
10814   jresult = new Dali::Radian((const Dali::Radian &)result);
10815   return jresult;
10816 }
10817
10818
10819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10820   void * jresult ;
10821   Dali::Radian arg1 ;
10822   Dali::Radian *argp1 ;
10823   Dali::Radian result;
10824
10825   argp1 = (Dali::Radian *)jarg1;
10826   if (!argp1) {
10827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10828     return 0;
10829   }
10830   arg1 = *argp1;
10831   {
10832     try {
10833       result = Dali::operator -(arg1);
10834     } catch (std::out_of_range& e) {
10835       {
10836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10837       };
10838     } catch (std::exception& e) {
10839       {
10840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10841       };
10842     } catch (Dali::DaliException e) {
10843       {
10844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10845       };
10846     } catch (...) {
10847       {
10848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10849       };
10850     }
10851   }
10852
10853   jresult = new Dali::Radian((const Dali::Radian &)result);
10854   return jresult;
10855 }
10856
10857
10858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10859   void * jresult ;
10860   Dali::Radian arg1 ;
10861   float arg2 ;
10862   float arg3 ;
10863   Dali::Radian *argp1 ;
10864   Dali::Radian result;
10865
10866   argp1 = (Dali::Radian *)jarg1;
10867   if (!argp1) {
10868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10869     return 0;
10870   }
10871   arg1 = *argp1;
10872   arg2 = (float)jarg2;
10873   arg3 = (float)jarg3;
10874   {
10875     try {
10876       result = Dali::Clamp(arg1,arg2,arg3);
10877     } catch (std::out_of_range& e) {
10878       {
10879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10880       };
10881     } catch (std::exception& e) {
10882       {
10883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10884       };
10885     } catch (Dali::DaliException e) {
10886       {
10887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10888       };
10889     } catch (...) {
10890       {
10891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10892       };
10893     }
10894   }
10895
10896   jresult = new Dali::Radian((const Dali::Radian &)result);
10897   return jresult;
10898 }
10899
10900
10901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10902   void * jresult ;
10903   Dali::Quaternion *result = 0 ;
10904
10905   {
10906     try {
10907       result = (Dali::Quaternion *)new Dali::Quaternion();
10908     } catch (std::out_of_range& e) {
10909       {
10910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10911       };
10912     } catch (std::exception& e) {
10913       {
10914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10915       };
10916     } catch (Dali::DaliException e) {
10917       {
10918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10919       };
10920     } catch (...) {
10921       {
10922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10923       };
10924     }
10925   }
10926
10927   jresult = (void *)result;
10928   return jresult;
10929 }
10930
10931
10932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10933   void * jresult ;
10934   Dali::Radian arg1 ;
10935   Dali::Vector3 *arg2 = 0 ;
10936   Dali::Radian *argp1 ;
10937   Dali::Quaternion *result = 0 ;
10938
10939   argp1 = (Dali::Radian *)jarg1;
10940   if (!argp1) {
10941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10942     return 0;
10943   }
10944   arg1 = *argp1;
10945   arg2 = (Dali::Vector3 *)jarg2;
10946   if (!arg2) {
10947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10948     return 0;
10949   }
10950   {
10951     try {
10952       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10953     } catch (std::out_of_range& e) {
10954       {
10955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10956       };
10957     } catch (std::exception& e) {
10958       {
10959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10960       };
10961     } catch (Dali::DaliException e) {
10962       {
10963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10964       };
10965     } catch (...) {
10966       {
10967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10968       };
10969     }
10970   }
10971
10972   jresult = (void *)result;
10973   return jresult;
10974 }
10975
10976
10977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10978   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10979
10980   arg1 = (Dali::Quaternion *)jarg1;
10981   {
10982     try {
10983       delete arg1;
10984     } catch (std::out_of_range& e) {
10985       {
10986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10987       };
10988     } catch (std::exception& e) {
10989       {
10990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10991       };
10992     } catch (Dali::DaliException e) {
10993       {
10994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10995       };
10996     } catch (...) {
10997       {
10998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10999       };
11000     }
11001   }
11002
11003 }
11004
11005
11006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
11007   void * jresult ;
11008   Dali::Quaternion *result = 0 ;
11009
11010   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
11011   jresult = (void *)result;
11012   return jresult;
11013 }
11014
11015
11016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
11017   unsigned int jresult ;
11018   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11019   bool result;
11020
11021   arg1 = (Dali::Quaternion *)jarg1;
11022   {
11023     try {
11024       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11025     } catch (std::out_of_range& e) {
11026       {
11027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11028       };
11029     } catch (std::exception& e) {
11030       {
11031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11032       };
11033     } catch (Dali::DaliException e) {
11034       {
11035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11036       };
11037     } catch (...) {
11038       {
11039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11040       };
11041     }
11042   }
11043
11044   jresult = result;
11045   return jresult;
11046 }
11047
11048
11049 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11050   unsigned int jresult ;
11051   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11052   Dali::Vector3 *arg2 = 0 ;
11053   Dali::Radian *arg3 = 0 ;
11054   bool result;
11055
11056   arg1 = (Dali::Quaternion *)jarg1;
11057   arg2 = (Dali::Vector3 *)jarg2;
11058   if (!arg2) {
11059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11060     return 0;
11061   }
11062   arg3 = (Dali::Radian *)jarg3;
11063   if (!arg3) {
11064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11065     return 0;
11066   }
11067   {
11068     try {
11069       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11070     } catch (std::out_of_range& e) {
11071       {
11072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11073       };
11074     } catch (std::exception& e) {
11075       {
11076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11077       };
11078     } catch (Dali::DaliException e) {
11079       {
11080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11081       };
11082     } catch (...) {
11083       {
11084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11085       };
11086     }
11087   }
11088
11089   jresult = result;
11090   return jresult;
11091 }
11092
11093
11094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11095   void * jresult ;
11096   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11097   Dali::Quaternion *arg2 = 0 ;
11098   Dali::Quaternion result;
11099
11100   arg1 = (Dali::Quaternion *)jarg1;
11101   arg2 = (Dali::Quaternion *)jarg2;
11102   if (!arg2) {
11103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11104     return 0;
11105   }
11106   {
11107     try {
11108       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11109     } catch (std::out_of_range& e) {
11110       {
11111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11112       };
11113     } catch (std::exception& e) {
11114       {
11115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11116       };
11117     } catch (Dali::DaliException e) {
11118       {
11119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11120       };
11121     } catch (...) {
11122       {
11123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11124       };
11125     }
11126   }
11127
11128   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11129   return jresult;
11130 }
11131
11132
11133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11134   void * jresult ;
11135   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11136   Dali::Quaternion *arg2 = 0 ;
11137   Dali::Quaternion result;
11138
11139   arg1 = (Dali::Quaternion *)jarg1;
11140   arg2 = (Dali::Quaternion *)jarg2;
11141   if (!arg2) {
11142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11143     return 0;
11144   }
11145   {
11146     try {
11147       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11148     } catch (std::out_of_range& e) {
11149       {
11150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11151       };
11152     } catch (std::exception& e) {
11153       {
11154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11155       };
11156     } catch (Dali::DaliException e) {
11157       {
11158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11159       };
11160     } catch (...) {
11161       {
11162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11163       };
11164     }
11165   }
11166
11167   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11168   return jresult;
11169 }
11170
11171
11172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11173   void * jresult ;
11174   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11175   Dali::Quaternion *arg2 = 0 ;
11176   Dali::Quaternion result;
11177
11178   arg1 = (Dali::Quaternion *)jarg1;
11179   arg2 = (Dali::Quaternion *)jarg2;
11180   if (!arg2) {
11181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11182     return 0;
11183   }
11184   {
11185     try {
11186       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11187     } catch (std::out_of_range& e) {
11188       {
11189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11190       };
11191     } catch (std::exception& e) {
11192       {
11193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11194       };
11195     } catch (Dali::DaliException e) {
11196       {
11197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11198       };
11199     } catch (...) {
11200       {
11201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11202       };
11203     }
11204   }
11205
11206   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11207   return jresult;
11208 }
11209
11210
11211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11212   void * jresult ;
11213   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11214   Dali::Vector3 *arg2 = 0 ;
11215   Dali::Vector3 result;
11216
11217   arg1 = (Dali::Quaternion *)jarg1;
11218   arg2 = (Dali::Vector3 *)jarg2;
11219   if (!arg2) {
11220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11221     return 0;
11222   }
11223   {
11224     try {
11225       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11226     } catch (std::out_of_range& e) {
11227       {
11228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11229       };
11230     } catch (std::exception& e) {
11231       {
11232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11233       };
11234     } catch (Dali::DaliException e) {
11235       {
11236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11237       };
11238     } catch (...) {
11239       {
11240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11241       };
11242     }
11243   }
11244
11245   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11246   return jresult;
11247 }
11248
11249
11250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11251   void * jresult ;
11252   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11253   Dali::Quaternion *arg2 = 0 ;
11254   Dali::Quaternion result;
11255
11256   arg1 = (Dali::Quaternion *)jarg1;
11257   arg2 = (Dali::Quaternion *)jarg2;
11258   if (!arg2) {
11259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11260     return 0;
11261   }
11262   {
11263     try {
11264       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11265     } catch (std::out_of_range& e) {
11266       {
11267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11268       };
11269     } catch (std::exception& e) {
11270       {
11271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11272       };
11273     } catch (Dali::DaliException e) {
11274       {
11275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11276       };
11277     } catch (...) {
11278       {
11279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11280       };
11281     }
11282   }
11283
11284   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11285   return jresult;
11286 }
11287
11288
11289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11290   void * jresult ;
11291   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11292   float arg2 ;
11293   Dali::Quaternion result;
11294
11295   arg1 = (Dali::Quaternion *)jarg1;
11296   arg2 = (float)jarg2;
11297   {
11298     try {
11299       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11300     } catch (std::out_of_range& e) {
11301       {
11302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11303       };
11304     } catch (std::exception& e) {
11305       {
11306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11307       };
11308     } catch (Dali::DaliException e) {
11309       {
11310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11311       };
11312     } catch (...) {
11313       {
11314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11315       };
11316     }
11317   }
11318
11319   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11320   return jresult;
11321 }
11322
11323
11324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11325   void * jresult ;
11326   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11327   float arg2 ;
11328   Dali::Quaternion result;
11329
11330   arg1 = (Dali::Quaternion *)jarg1;
11331   arg2 = (float)jarg2;
11332   {
11333     try {
11334       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11335     } catch (std::out_of_range& e) {
11336       {
11337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11338       };
11339     } catch (std::exception& e) {
11340       {
11341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11342       };
11343     } catch (Dali::DaliException e) {
11344       {
11345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11346       };
11347     } catch (...) {
11348       {
11349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11350       };
11351     }
11352   }
11353
11354   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11355   return jresult;
11356 }
11357
11358
11359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11360   void * jresult ;
11361   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11362   Dali::Quaternion result;
11363
11364   arg1 = (Dali::Quaternion *)jarg1;
11365   {
11366     try {
11367       result = ((Dali::Quaternion const *)arg1)->operator -();
11368     } catch (std::out_of_range& e) {
11369       {
11370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11371       };
11372     } catch (std::exception& e) {
11373       {
11374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11375       };
11376     } catch (Dali::DaliException e) {
11377       {
11378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11379       };
11380     } catch (...) {
11381       {
11382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11383       };
11384     }
11385   }
11386
11387   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11388   return jresult;
11389 }
11390
11391
11392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11393   void * jresult ;
11394   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11395   Dali::Quaternion *arg2 = 0 ;
11396   Dali::Quaternion *result = 0 ;
11397
11398   arg1 = (Dali::Quaternion *)jarg1;
11399   arg2 = (Dali::Quaternion *)jarg2;
11400   if (!arg2) {
11401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11402     return 0;
11403   }
11404   {
11405     try {
11406       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11407     } catch (std::out_of_range& e) {
11408       {
11409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11410       };
11411     } catch (std::exception& e) {
11412       {
11413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11414       };
11415     } catch (Dali::DaliException e) {
11416       {
11417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11418       };
11419     } catch (...) {
11420       {
11421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11422       };
11423     }
11424   }
11425
11426   jresult = (void *)result;
11427   return jresult;
11428 }
11429
11430
11431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11432   void * jresult ;
11433   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11434   Dali::Quaternion *arg2 = 0 ;
11435   Dali::Quaternion *result = 0 ;
11436
11437   arg1 = (Dali::Quaternion *)jarg1;
11438   arg2 = (Dali::Quaternion *)jarg2;
11439   if (!arg2) {
11440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11441     return 0;
11442   }
11443   {
11444     try {
11445       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11446     } catch (std::out_of_range& e) {
11447       {
11448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11449       };
11450     } catch (std::exception& e) {
11451       {
11452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11453       };
11454     } catch (Dali::DaliException e) {
11455       {
11456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11457       };
11458     } catch (...) {
11459       {
11460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11461       };
11462     }
11463   }
11464
11465   jresult = (void *)result;
11466   return jresult;
11467 }
11468
11469
11470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11471   void * jresult ;
11472   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11473   Dali::Quaternion *arg2 = 0 ;
11474   Dali::Quaternion *result = 0 ;
11475
11476   arg1 = (Dali::Quaternion *)jarg1;
11477   arg2 = (Dali::Quaternion *)jarg2;
11478   if (!arg2) {
11479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11480     return 0;
11481   }
11482   {
11483     try {
11484       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11485     } catch (std::out_of_range& e) {
11486       {
11487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11488       };
11489     } catch (std::exception& e) {
11490       {
11491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11492       };
11493     } catch (Dali::DaliException e) {
11494       {
11495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11496       };
11497     } catch (...) {
11498       {
11499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11500       };
11501     }
11502   }
11503
11504   jresult = (void *)result;
11505   return jresult;
11506 }
11507
11508
11509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11510   void * jresult ;
11511   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11512   float arg2 ;
11513   Dali::Quaternion *result = 0 ;
11514
11515   arg1 = (Dali::Quaternion *)jarg1;
11516   arg2 = (float)jarg2;
11517   {
11518     try {
11519       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11520     } catch (std::out_of_range& e) {
11521       {
11522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11523       };
11524     } catch (std::exception& e) {
11525       {
11526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11527       };
11528     } catch (Dali::DaliException e) {
11529       {
11530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11531       };
11532     } catch (...) {
11533       {
11534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11535       };
11536     }
11537   }
11538
11539   jresult = (void *)result;
11540   return jresult;
11541 }
11542
11543
11544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11545   void * jresult ;
11546   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11547   float arg2 ;
11548   Dali::Quaternion *result = 0 ;
11549
11550   arg1 = (Dali::Quaternion *)jarg1;
11551   arg2 = (float)jarg2;
11552   {
11553     try {
11554       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11555     } catch (std::out_of_range& e) {
11556       {
11557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11558       };
11559     } catch (std::exception& e) {
11560       {
11561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11562       };
11563     } catch (Dali::DaliException e) {
11564       {
11565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11566       };
11567     } catch (...) {
11568       {
11569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11570       };
11571     }
11572   }
11573
11574   jresult = (void *)result;
11575   return jresult;
11576 }
11577
11578
11579 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11580   unsigned int jresult ;
11581   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11582   Dali::Quaternion *arg2 = 0 ;
11583   bool result;
11584
11585   arg1 = (Dali::Quaternion *)jarg1;
11586   arg2 = (Dali::Quaternion *)jarg2;
11587   if (!arg2) {
11588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11589     return 0;
11590   }
11591   {
11592     try {
11593       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11594     } catch (std::out_of_range& e) {
11595       {
11596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11597       };
11598     } catch (std::exception& e) {
11599       {
11600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11601       };
11602     } catch (Dali::DaliException e) {
11603       {
11604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11605       };
11606     } catch (...) {
11607       {
11608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11609       };
11610     }
11611   }
11612
11613   jresult = result;
11614   return jresult;
11615 }
11616
11617
11618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11619   unsigned int jresult ;
11620   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11621   Dali::Quaternion *arg2 = 0 ;
11622   bool result;
11623
11624   arg1 = (Dali::Quaternion *)jarg1;
11625   arg2 = (Dali::Quaternion *)jarg2;
11626   if (!arg2) {
11627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11628     return 0;
11629   }
11630   {
11631     try {
11632       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11633     } catch (std::out_of_range& e) {
11634       {
11635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11636       };
11637     } catch (std::exception& e) {
11638       {
11639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11640       };
11641     } catch (Dali::DaliException e) {
11642       {
11643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11644       };
11645     } catch (...) {
11646       {
11647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11648       };
11649     }
11650   }
11651
11652   jresult = result;
11653   return jresult;
11654 }
11655
11656
11657 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11658   float jresult ;
11659   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11660   float result;
11661
11662   arg1 = (Dali::Quaternion *)jarg1;
11663   {
11664     try {
11665       result = (float)((Dali::Quaternion const *)arg1)->Length();
11666     } catch (std::out_of_range& e) {
11667       {
11668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11669       };
11670     } catch (std::exception& e) {
11671       {
11672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11673       };
11674     } catch (Dali::DaliException e) {
11675       {
11676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11677       };
11678     } catch (...) {
11679       {
11680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11681       };
11682     }
11683   }
11684
11685   jresult = result;
11686   return jresult;
11687 }
11688
11689
11690 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11691   float jresult ;
11692   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11693   float result;
11694
11695   arg1 = (Dali::Quaternion *)jarg1;
11696   {
11697     try {
11698       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11699     } catch (std::out_of_range& e) {
11700       {
11701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11702       };
11703     } catch (std::exception& e) {
11704       {
11705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11706       };
11707     } catch (Dali::DaliException e) {
11708       {
11709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11710       };
11711     } catch (...) {
11712       {
11713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11714       };
11715     }
11716   }
11717
11718   jresult = result;
11719   return jresult;
11720 }
11721
11722
11723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11724   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11725
11726   arg1 = (Dali::Quaternion *)jarg1;
11727   {
11728     try {
11729       (arg1)->Normalize();
11730     } catch (std::out_of_range& e) {
11731       {
11732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11733       };
11734     } catch (std::exception& e) {
11735       {
11736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11737       };
11738     } catch (Dali::DaliException e) {
11739       {
11740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11741       };
11742     } catch (...) {
11743       {
11744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11745       };
11746     }
11747   }
11748
11749 }
11750
11751
11752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11753   void * jresult ;
11754   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11755   Dali::Quaternion result;
11756
11757   arg1 = (Dali::Quaternion *)jarg1;
11758   {
11759     try {
11760       result = ((Dali::Quaternion const *)arg1)->Normalized();
11761     } catch (std::out_of_range& e) {
11762       {
11763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11764       };
11765     } catch (std::exception& e) {
11766       {
11767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11768       };
11769     } catch (Dali::DaliException e) {
11770       {
11771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11772       };
11773     } catch (...) {
11774       {
11775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11776       };
11777     }
11778   }
11779
11780   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11781   return jresult;
11782 }
11783
11784
11785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11786   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11787
11788   arg1 = (Dali::Quaternion *)jarg1;
11789   {
11790     try {
11791       (arg1)->Conjugate();
11792     } catch (std::out_of_range& e) {
11793       {
11794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11795       };
11796     } catch (std::exception& e) {
11797       {
11798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11799       };
11800     } catch (Dali::DaliException e) {
11801       {
11802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11803       };
11804     } catch (...) {
11805       {
11806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11807       };
11808     }
11809   }
11810
11811 }
11812
11813
11814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11815   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11816
11817   arg1 = (Dali::Quaternion *)jarg1;
11818   {
11819     try {
11820       (arg1)->Invert();
11821     } catch (std::out_of_range& e) {
11822       {
11823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11824       };
11825     } catch (std::exception& e) {
11826       {
11827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11828       };
11829     } catch (Dali::DaliException e) {
11830       {
11831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11832       };
11833     } catch (...) {
11834       {
11835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11836       };
11837     }
11838   }
11839
11840 }
11841
11842
11843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11844   void * jresult ;
11845   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11846   Dali::Quaternion result;
11847
11848   arg1 = (Dali::Quaternion *)jarg1;
11849   {
11850     try {
11851       result = ((Dali::Quaternion const *)arg1)->Log();
11852     } catch (std::out_of_range& e) {
11853       {
11854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11855       };
11856     } catch (std::exception& e) {
11857       {
11858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11859       };
11860     } catch (Dali::DaliException e) {
11861       {
11862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11863       };
11864     } catch (...) {
11865       {
11866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11867       };
11868     }
11869   }
11870
11871   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11872   return jresult;
11873 }
11874
11875
11876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11877   void * jresult ;
11878   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11879   Dali::Quaternion result;
11880
11881   arg1 = (Dali::Quaternion *)jarg1;
11882   {
11883     try {
11884       result = ((Dali::Quaternion const *)arg1)->Exp();
11885     } catch (std::out_of_range& e) {
11886       {
11887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11888       };
11889     } catch (std::exception& e) {
11890       {
11891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11892       };
11893     } catch (Dali::DaliException e) {
11894       {
11895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11896       };
11897     } catch (...) {
11898       {
11899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11900       };
11901     }
11902   }
11903
11904   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11905   return jresult;
11906 }
11907
11908
11909 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11910   float jresult ;
11911   Dali::Quaternion *arg1 = 0 ;
11912   Dali::Quaternion *arg2 = 0 ;
11913   float result;
11914
11915   arg1 = (Dali::Quaternion *)jarg1;
11916   if (!arg1) {
11917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11918     return 0;
11919   }
11920   arg2 = (Dali::Quaternion *)jarg2;
11921   if (!arg2) {
11922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11923     return 0;
11924   }
11925   {
11926     try {
11927       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11928     } catch (std::out_of_range& e) {
11929       {
11930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11931       };
11932     } catch (std::exception& e) {
11933       {
11934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11935       };
11936     } catch (Dali::DaliException e) {
11937       {
11938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11939       };
11940     } catch (...) {
11941       {
11942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11943       };
11944     }
11945   }
11946
11947   jresult = result;
11948   return jresult;
11949 }
11950
11951
11952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11953   void * jresult ;
11954   Dali::Quaternion *arg1 = 0 ;
11955   Dali::Quaternion *arg2 = 0 ;
11956   float arg3 ;
11957   Dali::Quaternion result;
11958
11959   arg1 = (Dali::Quaternion *)jarg1;
11960   if (!arg1) {
11961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11962     return 0;
11963   }
11964   arg2 = (Dali::Quaternion *)jarg2;
11965   if (!arg2) {
11966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11967     return 0;
11968   }
11969   arg3 = (float)jarg3;
11970   {
11971     try {
11972       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11973     } catch (std::out_of_range& e) {
11974       {
11975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11976       };
11977     } catch (std::exception& e) {
11978       {
11979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11980       };
11981     } catch (Dali::DaliException e) {
11982       {
11983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11984       };
11985     } catch (...) {
11986       {
11987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11988       };
11989     }
11990   }
11991
11992   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11993   return jresult;
11994 }
11995
11996
11997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11998   void * jresult ;
11999   Dali::Quaternion *arg1 = 0 ;
12000   Dali::Quaternion *arg2 = 0 ;
12001   float arg3 ;
12002   Dali::Quaternion result;
12003
12004   arg1 = (Dali::Quaternion *)jarg1;
12005   if (!arg1) {
12006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12007     return 0;
12008   }
12009   arg2 = (Dali::Quaternion *)jarg2;
12010   if (!arg2) {
12011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12012     return 0;
12013   }
12014   arg3 = (float)jarg3;
12015   {
12016     try {
12017       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12018     } catch (std::out_of_range& e) {
12019       {
12020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12021       };
12022     } catch (std::exception& e) {
12023       {
12024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12025       };
12026     } catch (Dali::DaliException e) {
12027       {
12028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12029       };
12030     } catch (...) {
12031       {
12032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12033       };
12034     }
12035   }
12036
12037   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12038   return jresult;
12039 }
12040
12041
12042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12043   void * jresult ;
12044   Dali::Quaternion *arg1 = 0 ;
12045   Dali::Quaternion *arg2 = 0 ;
12046   float arg3 ;
12047   Dali::Quaternion result;
12048
12049   arg1 = (Dali::Quaternion *)jarg1;
12050   if (!arg1) {
12051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12052     return 0;
12053   }
12054   arg2 = (Dali::Quaternion *)jarg2;
12055   if (!arg2) {
12056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12057     return 0;
12058   }
12059   arg3 = (float)jarg3;
12060   {
12061     try {
12062       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12063     } catch (std::out_of_range& e) {
12064       {
12065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12066       };
12067     } catch (std::exception& e) {
12068       {
12069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12070       };
12071     } catch (Dali::DaliException e) {
12072       {
12073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12074       };
12075     } catch (...) {
12076       {
12077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12078       };
12079     }
12080   }
12081
12082   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12083   return jresult;
12084 }
12085
12086
12087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12088   void * jresult ;
12089   Dali::Quaternion *arg1 = 0 ;
12090   Dali::Quaternion *arg2 = 0 ;
12091   Dali::Quaternion *arg3 = 0 ;
12092   Dali::Quaternion *arg4 = 0 ;
12093   float arg5 ;
12094   Dali::Quaternion result;
12095
12096   arg1 = (Dali::Quaternion *)jarg1;
12097   if (!arg1) {
12098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12099     return 0;
12100   }
12101   arg2 = (Dali::Quaternion *)jarg2;
12102   if (!arg2) {
12103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12104     return 0;
12105   }
12106   arg3 = (Dali::Quaternion *)jarg3;
12107   if (!arg3) {
12108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12109     return 0;
12110   }
12111   arg4 = (Dali::Quaternion *)jarg4;
12112   if (!arg4) {
12113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12114     return 0;
12115   }
12116   arg5 = (float)jarg5;
12117   {
12118     try {
12119       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12120     } catch (std::out_of_range& e) {
12121       {
12122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12123       };
12124     } catch (std::exception& e) {
12125       {
12126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12127       };
12128     } catch (Dali::DaliException e) {
12129       {
12130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12131       };
12132     } catch (...) {
12133       {
12134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12135       };
12136     }
12137   }
12138
12139   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12140   return jresult;
12141 }
12142
12143
12144 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12145   float jresult ;
12146   Dali::Quaternion *arg1 = 0 ;
12147   Dali::Quaternion *arg2 = 0 ;
12148   float result;
12149
12150   arg1 = (Dali::Quaternion *)jarg1;
12151   if (!arg1) {
12152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12153     return 0;
12154   }
12155   arg2 = (Dali::Quaternion *)jarg2;
12156   if (!arg2) {
12157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12158     return 0;
12159   }
12160   {
12161     try {
12162       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12163     } catch (std::out_of_range& e) {
12164       {
12165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12166       };
12167     } catch (std::exception& e) {
12168       {
12169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12170       };
12171     } catch (Dali::DaliException e) {
12172       {
12173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12174       };
12175     } catch (...) {
12176       {
12177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12178       };
12179     }
12180   }
12181
12182   jresult = result;
12183   return jresult;
12184 }
12185
12186
12187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12188   void * jresult ;
12189   Dali::Matrix *result = 0 ;
12190
12191   {
12192     try {
12193       result = (Dali::Matrix *)new Dali::Matrix();
12194     } catch (std::out_of_range& e) {
12195       {
12196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12197       };
12198     } catch (std::exception& e) {
12199       {
12200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12201       };
12202     } catch (Dali::DaliException e) {
12203       {
12204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12205       };
12206     } catch (...) {
12207       {
12208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12209       };
12210     }
12211   }
12212
12213   jresult = (void *)result;
12214   return jresult;
12215 }
12216
12217
12218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12219   void * jresult ;
12220   bool arg1 ;
12221   Dali::Matrix *result = 0 ;
12222
12223   arg1 = jarg1 ? true : false;
12224   {
12225     try {
12226       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12227     } catch (std::out_of_range& e) {
12228       {
12229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12230       };
12231     } catch (std::exception& e) {
12232       {
12233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12234       };
12235     } catch (Dali::DaliException e) {
12236       {
12237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12238       };
12239     } catch (...) {
12240       {
12241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12242       };
12243     }
12244   }
12245
12246   jresult = (void *)result;
12247   return jresult;
12248 }
12249
12250
12251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12252   void * jresult ;
12253   float *arg1 = (float *) 0 ;
12254   Dali::Matrix *result = 0 ;
12255
12256   arg1 = jarg1;
12257   {
12258     try {
12259       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12260     } catch (std::out_of_range& e) {
12261       {
12262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12263       };
12264     } catch (std::exception& e) {
12265       {
12266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12267       };
12268     } catch (Dali::DaliException e) {
12269       {
12270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12271       };
12272     } catch (...) {
12273       {
12274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12275       };
12276     }
12277   }
12278
12279   jresult = (void *)result;
12280
12281
12282   return jresult;
12283 }
12284
12285
12286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12287   void * jresult ;
12288   Dali::Quaternion *arg1 = 0 ;
12289   Dali::Matrix *result = 0 ;
12290
12291   arg1 = (Dali::Quaternion *)jarg1;
12292   if (!arg1) {
12293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12294     return 0;
12295   }
12296   {
12297     try {
12298       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12299     } catch (std::out_of_range& e) {
12300       {
12301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12302       };
12303     } catch (std::exception& e) {
12304       {
12305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12306       };
12307     } catch (Dali::DaliException e) {
12308       {
12309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12310       };
12311     } catch (...) {
12312       {
12313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12314       };
12315     }
12316   }
12317
12318   jresult = (void *)result;
12319   return jresult;
12320 }
12321
12322
12323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12324   void * jresult ;
12325   Dali::Matrix *arg1 = 0 ;
12326   Dali::Matrix *result = 0 ;
12327
12328   arg1 = (Dali::Matrix *)jarg1;
12329   if (!arg1) {
12330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12331     return 0;
12332   }
12333   {
12334     try {
12335       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12336     } catch (std::out_of_range& e) {
12337       {
12338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12339       };
12340     } catch (std::exception& e) {
12341       {
12342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12343       };
12344     } catch (Dali::DaliException e) {
12345       {
12346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12347       };
12348     } catch (...) {
12349       {
12350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12351       };
12352     }
12353   }
12354
12355   jresult = (void *)result;
12356   return jresult;
12357 }
12358
12359
12360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12361   void * jresult ;
12362   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12363   Dali::Matrix *arg2 = 0 ;
12364   Dali::Matrix *result = 0 ;
12365
12366   arg1 = (Dali::Matrix *)jarg1;
12367   arg2 = (Dali::Matrix *)jarg2;
12368   if (!arg2) {
12369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12370     return 0;
12371   }
12372   {
12373     try {
12374       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12375     } catch (std::out_of_range& e) {
12376       {
12377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12378       };
12379     } catch (std::exception& e) {
12380       {
12381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12382       };
12383     } catch (Dali::DaliException e) {
12384       {
12385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12386       };
12387     } catch (...) {
12388       {
12389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12390       };
12391     }
12392   }
12393
12394   jresult = (void *)result;
12395   return jresult;
12396 }
12397
12398
12399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12400   void * jresult ;
12401   Dali::Matrix *result = 0 ;
12402
12403   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12404   jresult = (void *)result;
12405   return jresult;
12406 }
12407
12408
12409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12410   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12411
12412   arg1 = (Dali::Matrix *)jarg1;
12413   {
12414     try {
12415       (arg1)->SetIdentity();
12416     } catch (std::out_of_range& e) {
12417       {
12418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12419       };
12420     } catch (std::exception& e) {
12421       {
12422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12423       };
12424     } catch (Dali::DaliException e) {
12425       {
12426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12427       };
12428     } catch (...) {
12429       {
12430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12431       };
12432     }
12433   }
12434
12435 }
12436
12437
12438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12439   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12440   Dali::Vector3 *arg2 = 0 ;
12441
12442   arg1 = (Dali::Matrix *)jarg1;
12443   arg2 = (Dali::Vector3 *)jarg2;
12444   if (!arg2) {
12445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12446     return ;
12447   }
12448   {
12449     try {
12450       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12451     } catch (std::out_of_range& e) {
12452       {
12453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12454       };
12455     } catch (std::exception& e) {
12456       {
12457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12458       };
12459     } catch (Dali::DaliException e) {
12460       {
12461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12462       };
12463     } catch (...) {
12464       {
12465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12466       };
12467     }
12468   }
12469
12470 }
12471
12472
12473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12474   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12475   Dali::Matrix *arg2 = 0 ;
12476
12477   arg1 = (Dali::Matrix *)jarg1;
12478   arg2 = (Dali::Matrix *)jarg2;
12479   if (!arg2) {
12480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12481     return ;
12482   }
12483   {
12484     try {
12485       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12486     } catch (std::out_of_range& e) {
12487       {
12488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12489       };
12490     } catch (std::exception& e) {
12491       {
12492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12493       };
12494     } catch (Dali::DaliException e) {
12495       {
12496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12497       };
12498     } catch (...) {
12499       {
12500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12501       };
12502     }
12503   }
12504
12505 }
12506
12507
12508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12509   unsigned int jresult ;
12510   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12511   bool result;
12512
12513   arg1 = (Dali::Matrix *)jarg1;
12514   {
12515     try {
12516       result = (bool)(arg1)->Invert();
12517     } catch (std::out_of_range& e) {
12518       {
12519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12520       };
12521     } catch (std::exception& e) {
12522       {
12523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12524       };
12525     } catch (Dali::DaliException e) {
12526       {
12527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12528       };
12529     } catch (...) {
12530       {
12531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12532       };
12533     }
12534   }
12535
12536   jresult = result;
12537   return jresult;
12538 }
12539
12540
12541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12542   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12543
12544   arg1 = (Dali::Matrix *)jarg1;
12545   {
12546     try {
12547       (arg1)->Transpose();
12548     } catch (std::out_of_range& e) {
12549       {
12550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12551       };
12552     } catch (std::exception& e) {
12553       {
12554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12555       };
12556     } catch (Dali::DaliException e) {
12557       {
12558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12559       };
12560     } catch (...) {
12561       {
12562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12563       };
12564     }
12565   }
12566
12567 }
12568
12569
12570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12571   void * jresult ;
12572   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12573   Dali::Vector3 result;
12574
12575   arg1 = (Dali::Matrix *)jarg1;
12576   {
12577     try {
12578       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12579     } catch (std::out_of_range& e) {
12580       {
12581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12582       };
12583     } catch (std::exception& e) {
12584       {
12585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12586       };
12587     } catch (Dali::DaliException e) {
12588       {
12589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12590       };
12591     } catch (...) {
12592       {
12593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12594       };
12595     }
12596   }
12597
12598   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12599   return jresult;
12600 }
12601
12602
12603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12604   void * jresult ;
12605   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12606   Dali::Vector3 result;
12607
12608   arg1 = (Dali::Matrix *)jarg1;
12609   {
12610     try {
12611       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12612     } catch (std::out_of_range& e) {
12613       {
12614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12615       };
12616     } catch (std::exception& e) {
12617       {
12618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12619       };
12620     } catch (Dali::DaliException e) {
12621       {
12622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12623       };
12624     } catch (...) {
12625       {
12626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12627       };
12628     }
12629   }
12630
12631   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12632   return jresult;
12633 }
12634
12635
12636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12637   void * jresult ;
12638   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12639   Dali::Vector3 result;
12640
12641   arg1 = (Dali::Matrix *)jarg1;
12642   {
12643     try {
12644       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12645     } catch (std::out_of_range& e) {
12646       {
12647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12648       };
12649     } catch (std::exception& e) {
12650       {
12651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12652       };
12653     } catch (Dali::DaliException e) {
12654       {
12655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12656       };
12657     } catch (...) {
12658       {
12659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12660       };
12661     }
12662   }
12663
12664   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12665   return jresult;
12666 }
12667
12668
12669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12670   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12671   Dali::Vector3 *arg2 = 0 ;
12672
12673   arg1 = (Dali::Matrix *)jarg1;
12674   arg2 = (Dali::Vector3 *)jarg2;
12675   if (!arg2) {
12676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12677     return ;
12678   }
12679   {
12680     try {
12681       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12682     } catch (std::out_of_range& e) {
12683       {
12684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12685       };
12686     } catch (std::exception& e) {
12687       {
12688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12689       };
12690     } catch (Dali::DaliException e) {
12691       {
12692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12693       };
12694     } catch (...) {
12695       {
12696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12697       };
12698     }
12699   }
12700
12701 }
12702
12703
12704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12705   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12706   Dali::Vector3 *arg2 = 0 ;
12707
12708   arg1 = (Dali::Matrix *)jarg1;
12709   arg2 = (Dali::Vector3 *)jarg2;
12710   if (!arg2) {
12711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12712     return ;
12713   }
12714   {
12715     try {
12716       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12717     } catch (std::out_of_range& e) {
12718       {
12719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12720       };
12721     } catch (std::exception& e) {
12722       {
12723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12724       };
12725     } catch (Dali::DaliException e) {
12726       {
12727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12728       };
12729     } catch (...) {
12730       {
12731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12732       };
12733     }
12734   }
12735
12736 }
12737
12738
12739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12740   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12741   Dali::Vector3 *arg2 = 0 ;
12742
12743   arg1 = (Dali::Matrix *)jarg1;
12744   arg2 = (Dali::Vector3 *)jarg2;
12745   if (!arg2) {
12746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12747     return ;
12748   }
12749   {
12750     try {
12751       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12752     } catch (std::out_of_range& e) {
12753       {
12754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12755       };
12756     } catch (std::exception& e) {
12757       {
12758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12759       };
12760     } catch (Dali::DaliException e) {
12761       {
12762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12763       };
12764     } catch (...) {
12765       {
12766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12767       };
12768     }
12769   }
12770
12771 }
12772
12773
12774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12775   void * jresult ;
12776   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12777   Dali::Vector4 *result = 0 ;
12778
12779   arg1 = (Dali::Matrix *)jarg1;
12780   {
12781     try {
12782       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12783     } catch (std::out_of_range& e) {
12784       {
12785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12786       };
12787     } catch (std::exception& e) {
12788       {
12789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12790       };
12791     } catch (Dali::DaliException e) {
12792       {
12793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12794       };
12795     } catch (...) {
12796       {
12797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12798       };
12799     }
12800   }
12801
12802   jresult = (void *)result;
12803   return jresult;
12804 }
12805
12806
12807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12808   void * jresult ;
12809   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12810   Dali::Vector3 *result = 0 ;
12811
12812   arg1 = (Dali::Matrix *)jarg1;
12813   {
12814     try {
12815       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12816     } catch (std::out_of_range& e) {
12817       {
12818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12819       };
12820     } catch (std::exception& e) {
12821       {
12822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12823       };
12824     } catch (Dali::DaliException e) {
12825       {
12826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12827       };
12828     } catch (...) {
12829       {
12830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12831       };
12832     }
12833   }
12834
12835   jresult = (void *)result;
12836   return jresult;
12837 }
12838
12839
12840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12841   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12842   Dali::Vector4 *arg2 = 0 ;
12843
12844   arg1 = (Dali::Matrix *)jarg1;
12845   arg2 = (Dali::Vector4 *)jarg2;
12846   if (!arg2) {
12847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12848     return ;
12849   }
12850   {
12851     try {
12852       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12853     } catch (std::out_of_range& e) {
12854       {
12855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12856       };
12857     } catch (std::exception& e) {
12858       {
12859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12860       };
12861     } catch (Dali::DaliException e) {
12862       {
12863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12864       };
12865     } catch (...) {
12866       {
12867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12868       };
12869     }
12870   }
12871
12872 }
12873
12874
12875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12876   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12877   Dali::Vector3 *arg2 = 0 ;
12878
12879   arg1 = (Dali::Matrix *)jarg1;
12880   arg2 = (Dali::Vector3 *)jarg2;
12881   if (!arg2) {
12882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12883     return ;
12884   }
12885   {
12886     try {
12887       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12888     } catch (std::out_of_range& e) {
12889       {
12890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12891       };
12892     } catch (std::exception& e) {
12893       {
12894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12895       };
12896     } catch (Dali::DaliException e) {
12897       {
12898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12899       };
12900     } catch (...) {
12901       {
12902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12903       };
12904     }
12905   }
12906
12907 }
12908
12909
12910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12911   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12912
12913   arg1 = (Dali::Matrix *)jarg1;
12914   {
12915     try {
12916       (arg1)->OrthoNormalize();
12917     } catch (std::out_of_range& e) {
12918       {
12919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12920       };
12921     } catch (std::exception& e) {
12922       {
12923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12924       };
12925     } catch (Dali::DaliException e) {
12926       {
12927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12928       };
12929     } catch (...) {
12930       {
12931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12932       };
12933     }
12934   }
12935
12936 }
12937
12938
12939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12940   void * jresult ;
12941   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12942   float *result = 0 ;
12943
12944   arg1 = (Dali::Matrix *)jarg1;
12945   {
12946     try {
12947       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12948     } catch (std::out_of_range& e) {
12949       {
12950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12951       };
12952     } catch (std::exception& e) {
12953       {
12954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12955       };
12956     } catch (Dali::DaliException e) {
12957       {
12958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12959       };
12960     } catch (...) {
12961       {
12962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12963       };
12964     }
12965   }
12966
12967   jresult = (void *)result;
12968   return jresult;
12969 }
12970
12971
12972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12973   Dali::Matrix *arg1 = 0 ;
12974   Dali::Matrix *arg2 = 0 ;
12975   Dali::Matrix *arg3 = 0 ;
12976
12977   arg1 = (Dali::Matrix *)jarg1;
12978   if (!arg1) {
12979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12980     return ;
12981   }
12982   arg2 = (Dali::Matrix *)jarg2;
12983   if (!arg2) {
12984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12985     return ;
12986   }
12987   arg3 = (Dali::Matrix *)jarg3;
12988   if (!arg3) {
12989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12990     return ;
12991   }
12992   {
12993     try {
12994       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12995     } catch (std::out_of_range& e) {
12996       {
12997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12998       };
12999     } catch (std::exception& e) {
13000       {
13001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13002       };
13003     } catch (Dali::DaliException e) {
13004       {
13005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13006       };
13007     } catch (...) {
13008       {
13009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13010       };
13011     }
13012   }
13013
13014 }
13015
13016
13017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13018   Dali::Matrix *arg1 = 0 ;
13019   Dali::Matrix *arg2 = 0 ;
13020   Dali::Quaternion *arg3 = 0 ;
13021
13022   arg1 = (Dali::Matrix *)jarg1;
13023   if (!arg1) {
13024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13025     return ;
13026   }
13027   arg2 = (Dali::Matrix *)jarg2;
13028   if (!arg2) {
13029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13030     return ;
13031   }
13032   arg3 = (Dali::Quaternion *)jarg3;
13033   if (!arg3) {
13034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13035     return ;
13036   }
13037   {
13038     try {
13039       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13040     } catch (std::out_of_range& e) {
13041       {
13042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13043       };
13044     } catch (std::exception& e) {
13045       {
13046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13047       };
13048     } catch (Dali::DaliException e) {
13049       {
13050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13051       };
13052     } catch (...) {
13053       {
13054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13055       };
13056     }
13057   }
13058
13059 }
13060
13061
13062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13063   void * jresult ;
13064   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13065   Dali::Vector4 *arg2 = 0 ;
13066   Dali::Vector4 result;
13067
13068   arg1 = (Dali::Matrix *)jarg1;
13069   arg2 = (Dali::Vector4 *)jarg2;
13070   if (!arg2) {
13071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13072     return 0;
13073   }
13074   {
13075     try {
13076       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13077     } catch (std::out_of_range& e) {
13078       {
13079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13080       };
13081     } catch (std::exception& e) {
13082       {
13083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13084       };
13085     } catch (Dali::DaliException e) {
13086       {
13087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13088       };
13089     } catch (...) {
13090       {
13091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13092       };
13093     }
13094   }
13095
13096   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13097   return jresult;
13098 }
13099
13100
13101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13102   unsigned int jresult ;
13103   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13104   Dali::Matrix *arg2 = 0 ;
13105   bool result;
13106
13107   arg1 = (Dali::Matrix *)jarg1;
13108   arg2 = (Dali::Matrix *)jarg2;
13109   if (!arg2) {
13110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13111     return 0;
13112   }
13113   {
13114     try {
13115       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13116     } catch (std::out_of_range& e) {
13117       {
13118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13119       };
13120     } catch (std::exception& e) {
13121       {
13122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13123       };
13124     } catch (Dali::DaliException e) {
13125       {
13126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13127       };
13128     } catch (...) {
13129       {
13130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13131       };
13132     }
13133   }
13134
13135   jresult = result;
13136   return jresult;
13137 }
13138
13139
13140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13141   unsigned int jresult ;
13142   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13143   Dali::Matrix *arg2 = 0 ;
13144   bool result;
13145
13146   arg1 = (Dali::Matrix *)jarg1;
13147   arg2 = (Dali::Matrix *)jarg2;
13148   if (!arg2) {
13149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13150     return 0;
13151   }
13152   {
13153     try {
13154       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13155     } catch (std::out_of_range& e) {
13156       {
13157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13158       };
13159     } catch (std::exception& e) {
13160       {
13161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13162       };
13163     } catch (Dali::DaliException e) {
13164       {
13165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13166       };
13167     } catch (...) {
13168       {
13169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13170       };
13171     }
13172   }
13173
13174   jresult = result;
13175   return jresult;
13176 }
13177
13178
13179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13180   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13181   Dali::Vector3 *arg2 = 0 ;
13182   Dali::Quaternion *arg3 = 0 ;
13183   Dali::Vector3 *arg4 = 0 ;
13184
13185   arg1 = (Dali::Matrix *)jarg1;
13186   arg2 = (Dali::Vector3 *)jarg2;
13187   if (!arg2) {
13188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13189     return ;
13190   }
13191   arg3 = (Dali::Quaternion *)jarg3;
13192   if (!arg3) {
13193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13194     return ;
13195   }
13196   arg4 = (Dali::Vector3 *)jarg4;
13197   if (!arg4) {
13198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13199     return ;
13200   }
13201   {
13202     try {
13203       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13204     } catch (std::out_of_range& e) {
13205       {
13206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13207       };
13208     } catch (std::exception& e) {
13209       {
13210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13211       };
13212     } catch (Dali::DaliException e) {
13213       {
13214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13215       };
13216     } catch (...) {
13217       {
13218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13219       };
13220     }
13221   }
13222
13223 }
13224
13225
13226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13227   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13228   Dali::Vector3 *arg2 = 0 ;
13229   Dali::Quaternion *arg3 = 0 ;
13230   Dali::Vector3 *arg4 = 0 ;
13231
13232   arg1 = (Dali::Matrix *)jarg1;
13233   arg2 = (Dali::Vector3 *)jarg2;
13234   if (!arg2) {
13235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13236     return ;
13237   }
13238   arg3 = (Dali::Quaternion *)jarg3;
13239   if (!arg3) {
13240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13241     return ;
13242   }
13243   arg4 = (Dali::Vector3 *)jarg4;
13244   if (!arg4) {
13245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13246     return ;
13247   }
13248   {
13249     try {
13250       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13251     } catch (std::out_of_range& e) {
13252       {
13253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13254       };
13255     } catch (std::exception& e) {
13256       {
13257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13258       };
13259     } catch (Dali::DaliException e) {
13260       {
13261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13262       };
13263     } catch (...) {
13264       {
13265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13266       };
13267     }
13268   }
13269
13270 }
13271
13272
13273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13274   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13275   Dali::Vector3 *arg2 = 0 ;
13276   Dali::Vector3 *arg3 = 0 ;
13277   Dali::Vector3 *arg4 = 0 ;
13278   Dali::Vector3 *arg5 = 0 ;
13279
13280   arg1 = (Dali::Matrix *)jarg1;
13281   arg2 = (Dali::Vector3 *)jarg2;
13282   if (!arg2) {
13283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13284     return ;
13285   }
13286   arg3 = (Dali::Vector3 *)jarg3;
13287   if (!arg3) {
13288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13289     return ;
13290   }
13291   arg4 = (Dali::Vector3 *)jarg4;
13292   if (!arg4) {
13293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13294     return ;
13295   }
13296   arg5 = (Dali::Vector3 *)jarg5;
13297   if (!arg5) {
13298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13299     return ;
13300   }
13301   {
13302     try {
13303       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13304     } catch (std::out_of_range& e) {
13305       {
13306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13307       };
13308     } catch (std::exception& e) {
13309       {
13310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13311       };
13312     } catch (Dali::DaliException e) {
13313       {
13314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13315       };
13316     } catch (...) {
13317       {
13318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13319       };
13320     }
13321   }
13322
13323 }
13324
13325
13326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13327   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13328   Dali::Vector3 *arg2 = 0 ;
13329   Dali::Quaternion *arg3 = 0 ;
13330   Dali::Vector3 *arg4 = 0 ;
13331
13332   arg1 = (Dali::Matrix *)jarg1;
13333   arg2 = (Dali::Vector3 *)jarg2;
13334   if (!arg2) {
13335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13336     return ;
13337   }
13338   arg3 = (Dali::Quaternion *)jarg3;
13339   if (!arg3) {
13340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13341     return ;
13342   }
13343   arg4 = (Dali::Vector3 *)jarg4;
13344   if (!arg4) {
13345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13346     return ;
13347   }
13348   {
13349     try {
13350       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13351     } catch (std::out_of_range& e) {
13352       {
13353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13354       };
13355     } catch (std::exception& e) {
13356       {
13357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13358       };
13359     } catch (Dali::DaliException e) {
13360       {
13361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13362       };
13363     } catch (...) {
13364       {
13365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13366       };
13367     }
13368   }
13369
13370 }
13371
13372
13373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13374   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13375
13376   arg1 = (Dali::Matrix *)jarg1;
13377   {
13378     try {
13379       delete arg1;
13380     } catch (std::out_of_range& e) {
13381       {
13382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13383       };
13384     } catch (std::exception& e) {
13385       {
13386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13387       };
13388     } catch (Dali::DaliException e) {
13389       {
13390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13391       };
13392     } catch (...) {
13393       {
13394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13395       };
13396     }
13397   }
13398
13399 }
13400
13401
13402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13403   void * jresult ;
13404   Dali::Matrix3 *result = 0 ;
13405
13406   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13407   jresult = (void *)result;
13408   return jresult;
13409 }
13410
13411
13412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13413   void * jresult ;
13414   Dali::Matrix3 *result = 0 ;
13415
13416   {
13417     try {
13418       result = (Dali::Matrix3 *)new Dali::Matrix3();
13419     } catch (std::out_of_range& e) {
13420       {
13421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13422       };
13423     } catch (std::exception& e) {
13424       {
13425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13426       };
13427     } catch (Dali::DaliException e) {
13428       {
13429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13430       };
13431     } catch (...) {
13432       {
13433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13434       };
13435     }
13436   }
13437
13438   jresult = (void *)result;
13439   return jresult;
13440 }
13441
13442
13443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13444   void * jresult ;
13445   Dali::Matrix3 *arg1 = 0 ;
13446   Dali::Matrix3 *result = 0 ;
13447
13448   arg1 = (Dali::Matrix3 *)jarg1;
13449   if (!arg1) {
13450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13451     return 0;
13452   }
13453   {
13454     try {
13455       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13456     } catch (std::out_of_range& e) {
13457       {
13458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13459       };
13460     } catch (std::exception& e) {
13461       {
13462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13463       };
13464     } catch (Dali::DaliException e) {
13465       {
13466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13467       };
13468     } catch (...) {
13469       {
13470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13471       };
13472     }
13473   }
13474
13475   jresult = (void *)result;
13476   return jresult;
13477 }
13478
13479
13480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13481   void * jresult ;
13482   Dali::Matrix *arg1 = 0 ;
13483   Dali::Matrix3 *result = 0 ;
13484
13485   arg1 = (Dali::Matrix *)jarg1;
13486   if (!arg1) {
13487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13488     return 0;
13489   }
13490   {
13491     try {
13492       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13493     } catch (std::out_of_range& e) {
13494       {
13495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13496       };
13497     } catch (std::exception& e) {
13498       {
13499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13500       };
13501     } catch (Dali::DaliException e) {
13502       {
13503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13504       };
13505     } catch (...) {
13506       {
13507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13508       };
13509     }
13510   }
13511
13512   jresult = (void *)result;
13513   return jresult;
13514 }
13515
13516
13517 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) {
13518   void * jresult ;
13519   float arg1 ;
13520   float arg2 ;
13521   float arg3 ;
13522   float arg4 ;
13523   float arg5 ;
13524   float arg6 ;
13525   float arg7 ;
13526   float arg8 ;
13527   float arg9 ;
13528   Dali::Matrix3 *result = 0 ;
13529
13530   arg1 = (float)jarg1;
13531   arg2 = (float)jarg2;
13532   arg3 = (float)jarg3;
13533   arg4 = (float)jarg4;
13534   arg5 = (float)jarg5;
13535   arg6 = (float)jarg6;
13536   arg7 = (float)jarg7;
13537   arg8 = (float)jarg8;
13538   arg9 = (float)jarg9;
13539   {
13540     try {
13541       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13542     } catch (std::out_of_range& e) {
13543       {
13544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13545       };
13546     } catch (std::exception& e) {
13547       {
13548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13549       };
13550     } catch (Dali::DaliException e) {
13551       {
13552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13553       };
13554     } catch (...) {
13555       {
13556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13557       };
13558     }
13559   }
13560
13561   jresult = (void *)result;
13562   return jresult;
13563 }
13564
13565
13566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13567   void * jresult ;
13568   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13569   Dali::Matrix3 *arg2 = 0 ;
13570   Dali::Matrix3 *result = 0 ;
13571
13572   arg1 = (Dali::Matrix3 *)jarg1;
13573   arg2 = (Dali::Matrix3 *)jarg2;
13574   if (!arg2) {
13575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13576     return 0;
13577   }
13578   {
13579     try {
13580       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13581     } catch (std::out_of_range& e) {
13582       {
13583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13584       };
13585     } catch (std::exception& e) {
13586       {
13587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13588       };
13589     } catch (Dali::DaliException e) {
13590       {
13591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13592       };
13593     } catch (...) {
13594       {
13595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13596       };
13597     }
13598   }
13599
13600   jresult = (void *)result;
13601   return jresult;
13602 }
13603
13604
13605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13606   void * jresult ;
13607   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13608   Dali::Matrix *arg2 = 0 ;
13609   Dali::Matrix3 *result = 0 ;
13610
13611   arg1 = (Dali::Matrix3 *)jarg1;
13612   arg2 = (Dali::Matrix *)jarg2;
13613   if (!arg2) {
13614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13615     return 0;
13616   }
13617   {
13618     try {
13619       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13620     } catch (std::out_of_range& e) {
13621       {
13622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13623       };
13624     } catch (std::exception& e) {
13625       {
13626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13627       };
13628     } catch (Dali::DaliException e) {
13629       {
13630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13631       };
13632     } catch (...) {
13633       {
13634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13635       };
13636     }
13637   }
13638
13639   jresult = (void *)result;
13640   return jresult;
13641 }
13642
13643
13644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13645   unsigned int jresult ;
13646   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13647   Dali::Matrix3 *arg2 = 0 ;
13648   bool result;
13649
13650   arg1 = (Dali::Matrix3 *)jarg1;
13651   arg2 = (Dali::Matrix3 *)jarg2;
13652   if (!arg2) {
13653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13654     return 0;
13655   }
13656   {
13657     try {
13658       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13659     } catch (std::out_of_range& e) {
13660       {
13661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13662       };
13663     } catch (std::exception& e) {
13664       {
13665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13666       };
13667     } catch (Dali::DaliException e) {
13668       {
13669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13670       };
13671     } catch (...) {
13672       {
13673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13674       };
13675     }
13676   }
13677
13678   jresult = result;
13679   return jresult;
13680 }
13681
13682
13683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13684   unsigned int jresult ;
13685   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13686   Dali::Matrix3 *arg2 = 0 ;
13687   bool result;
13688
13689   arg1 = (Dali::Matrix3 *)jarg1;
13690   arg2 = (Dali::Matrix3 *)jarg2;
13691   if (!arg2) {
13692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13693     return 0;
13694   }
13695   {
13696     try {
13697       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13698     } catch (std::out_of_range& e) {
13699       {
13700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13701       };
13702     } catch (std::exception& e) {
13703       {
13704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13705       };
13706     } catch (Dali::DaliException e) {
13707       {
13708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13709       };
13710     } catch (...) {
13711       {
13712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13713       };
13714     }
13715   }
13716
13717   jresult = result;
13718   return jresult;
13719 }
13720
13721
13722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13723   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13724
13725   arg1 = (Dali::Matrix3 *)jarg1;
13726   {
13727     try {
13728       delete arg1;
13729     } catch (std::out_of_range& e) {
13730       {
13731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13732       };
13733     } catch (std::exception& e) {
13734       {
13735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13736       };
13737     } catch (Dali::DaliException e) {
13738       {
13739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13740       };
13741     } catch (...) {
13742       {
13743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13744       };
13745     }
13746   }
13747
13748 }
13749
13750
13751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13752   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13753
13754   arg1 = (Dali::Matrix3 *)jarg1;
13755   {
13756     try {
13757       (arg1)->SetIdentity();
13758     } catch (std::out_of_range& e) {
13759       {
13760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13761       };
13762     } catch (std::exception& e) {
13763       {
13764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13765       };
13766     } catch (Dali::DaliException e) {
13767       {
13768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13769       };
13770     } catch (...) {
13771       {
13772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13773       };
13774     }
13775   }
13776
13777 }
13778
13779
13780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13781   void * jresult ;
13782   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13783   float *result = 0 ;
13784
13785   arg1 = (Dali::Matrix3 *)jarg1;
13786   {
13787     try {
13788       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13789     } catch (std::out_of_range& e) {
13790       {
13791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13792       };
13793     } catch (std::exception& e) {
13794       {
13795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13796       };
13797     } catch (Dali::DaliException e) {
13798       {
13799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13800       };
13801     } catch (...) {
13802       {
13803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13804       };
13805     }
13806   }
13807
13808   jresult = (void *)result;
13809   return jresult;
13810 }
13811
13812
13813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13814   unsigned int jresult ;
13815   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13816   bool result;
13817
13818   arg1 = (Dali::Matrix3 *)jarg1;
13819   {
13820     try {
13821       result = (bool)(arg1)->Invert();
13822     } catch (std::out_of_range& e) {
13823       {
13824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13825       };
13826     } catch (std::exception& e) {
13827       {
13828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13829       };
13830     } catch (Dali::DaliException e) {
13831       {
13832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13833       };
13834     } catch (...) {
13835       {
13836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13837       };
13838     }
13839   }
13840
13841   jresult = result;
13842   return jresult;
13843 }
13844
13845
13846 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13847   unsigned int jresult ;
13848   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13849   bool result;
13850
13851   arg1 = (Dali::Matrix3 *)jarg1;
13852   {
13853     try {
13854       result = (bool)(arg1)->Transpose();
13855     } catch (std::out_of_range& e) {
13856       {
13857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13858       };
13859     } catch (std::exception& e) {
13860       {
13861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13862       };
13863     } catch (Dali::DaliException e) {
13864       {
13865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13866       };
13867     } catch (...) {
13868       {
13869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13870       };
13871     }
13872   }
13873
13874   jresult = result;
13875   return jresult;
13876 }
13877
13878
13879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13880   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13881   float arg2 ;
13882
13883   arg1 = (Dali::Matrix3 *)jarg1;
13884   arg2 = (float)jarg2;
13885   {
13886     try {
13887       (arg1)->Scale(arg2);
13888     } catch (std::out_of_range& e) {
13889       {
13890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13891       };
13892     } catch (std::exception& e) {
13893       {
13894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13895       };
13896     } catch (Dali::DaliException e) {
13897       {
13898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13899       };
13900     } catch (...) {
13901       {
13902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13903       };
13904     }
13905   }
13906
13907 }
13908
13909
13910 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13911   float jresult ;
13912   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13913   float result;
13914
13915   arg1 = (Dali::Matrix3 *)jarg1;
13916   {
13917     try {
13918       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13919     } catch (std::out_of_range& e) {
13920       {
13921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13922       };
13923     } catch (std::exception& e) {
13924       {
13925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13926       };
13927     } catch (Dali::DaliException e) {
13928       {
13929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13930       };
13931     } catch (...) {
13932       {
13933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13934       };
13935     }
13936   }
13937
13938   jresult = result;
13939   return jresult;
13940 }
13941
13942
13943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13944   unsigned int jresult ;
13945   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13946   bool result;
13947
13948   arg1 = (Dali::Matrix3 *)jarg1;
13949   {
13950     try {
13951       result = (bool)(arg1)->ScaledInverseTranspose();
13952     } catch (std::out_of_range& e) {
13953       {
13954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13955       };
13956     } catch (std::exception& e) {
13957       {
13958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13959       };
13960     } catch (Dali::DaliException e) {
13961       {
13962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13963       };
13964     } catch (...) {
13965       {
13966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13967       };
13968     }
13969   }
13970
13971   jresult = result;
13972   return jresult;
13973 }
13974
13975
13976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13977   Dali::Matrix3 *arg1 = 0 ;
13978   Dali::Matrix3 *arg2 = 0 ;
13979   Dali::Matrix3 *arg3 = 0 ;
13980
13981   arg1 = (Dali::Matrix3 *)jarg1;
13982   if (!arg1) {
13983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13984     return ;
13985   }
13986   arg2 = (Dali::Matrix3 *)jarg2;
13987   if (!arg2) {
13988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13989     return ;
13990   }
13991   arg3 = (Dali::Matrix3 *)jarg3;
13992   if (!arg3) {
13993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13994     return ;
13995   }
13996   {
13997     try {
13998       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13999     } catch (std::out_of_range& e) {
14000       {
14001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14002       };
14003     } catch (std::exception& e) {
14004       {
14005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14006       };
14007     } catch (Dali::DaliException e) {
14008       {
14009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14010       };
14011     } catch (...) {
14012       {
14013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14014       };
14015     }
14016   }
14017
14018 }
14019
14020
14021 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14022   float jresult ;
14023   float arg1 ;
14024   float arg2 ;
14025   float result;
14026
14027   arg1 = (float)jarg1;
14028   arg2 = (float)jarg2;
14029   {
14030     try {
14031       result = (float)Dali::Random::Range(arg1,arg2);
14032     } catch (std::out_of_range& e) {
14033       {
14034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14035       };
14036     } catch (std::exception& e) {
14037       {
14038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14039       };
14040     } catch (Dali::DaliException e) {
14041       {
14042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14043       };
14044     } catch (...) {
14045       {
14046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14047       };
14048     }
14049   }
14050
14051   jresult = result;
14052   return jresult;
14053 }
14054
14055
14056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14057   void * jresult ;
14058   Dali::Vector4 result;
14059
14060   {
14061     try {
14062       result = Dali::Random::Axis();
14063     } catch (std::out_of_range& e) {
14064       {
14065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14066       };
14067     } catch (std::exception& e) {
14068       {
14069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14070       };
14071     } catch (Dali::DaliException e) {
14072       {
14073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14074       };
14075     } catch (...) {
14076       {
14077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14078       };
14079     }
14080   }
14081
14082   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14083   return jresult;
14084 }
14085
14086
14087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14088   void * jresult ;
14089   Dali::AngleAxis *result = 0 ;
14090
14091   {
14092     try {
14093       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14094     } catch (std::out_of_range& e) {
14095       {
14096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14097       };
14098     } catch (std::exception& e) {
14099       {
14100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14101       };
14102     } catch (Dali::DaliException e) {
14103       {
14104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14105       };
14106     } catch (...) {
14107       {
14108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14109       };
14110     }
14111   }
14112
14113   jresult = (void *)result;
14114   return jresult;
14115 }
14116
14117
14118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14119   void * jresult ;
14120   Dali::Radian arg1 ;
14121   Dali::Vector3 *arg2 = 0 ;
14122   Dali::Radian *argp1 ;
14123   Dali::AngleAxis *result = 0 ;
14124
14125   argp1 = (Dali::Radian *)jarg1;
14126   if (!argp1) {
14127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14128     return 0;
14129   }
14130   arg1 = *argp1;
14131   arg2 = (Dali::Vector3 *)jarg2;
14132   if (!arg2) {
14133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14134     return 0;
14135   }
14136   {
14137     try {
14138       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14139     } catch (std::out_of_range& e) {
14140       {
14141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14142       };
14143     } catch (std::exception& e) {
14144       {
14145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14146       };
14147     } catch (Dali::DaliException e) {
14148       {
14149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14150       };
14151     } catch (...) {
14152       {
14153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14154       };
14155     }
14156   }
14157
14158   jresult = (void *)result;
14159   return jresult;
14160 }
14161
14162
14163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14164   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14165   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14166
14167   arg1 = (Dali::AngleAxis *)jarg1;
14168   arg2 = (Dali::Radian *)jarg2;
14169   if (arg1) (arg1)->angle = *arg2;
14170 }
14171
14172
14173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14174   void * jresult ;
14175   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14176   Dali::Radian *result = 0 ;
14177
14178   arg1 = (Dali::AngleAxis *)jarg1;
14179   result = (Dali::Radian *)& ((arg1)->angle);
14180   jresult = (void *)result;
14181   return jresult;
14182 }
14183
14184
14185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14186   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14187   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14188
14189   arg1 = (Dali::AngleAxis *)jarg1;
14190   arg2 = (Dali::Vector3 *)jarg2;
14191   if (arg1) (arg1)->axis = *arg2;
14192 }
14193
14194
14195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14196   void * jresult ;
14197   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14198   Dali::Vector3 *result = 0 ;
14199
14200   arg1 = (Dali::AngleAxis *)jarg1;
14201   result = (Dali::Vector3 *)& ((arg1)->axis);
14202   jresult = (void *)result;
14203   return jresult;
14204 }
14205
14206
14207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14208   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14209
14210   arg1 = (Dali::AngleAxis *)jarg1;
14211   {
14212     try {
14213       delete arg1;
14214     } catch (std::out_of_range& e) {
14215       {
14216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14217       };
14218     } catch (std::exception& e) {
14219       {
14220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14221       };
14222     } catch (Dali::DaliException e) {
14223       {
14224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14225       };
14226     } catch (...) {
14227       {
14228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14229       };
14230     }
14231   }
14232
14233 }
14234
14235
14236 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14237   unsigned int jresult ;
14238   Dali::AngleAxis *arg1 = 0 ;
14239   Dali::AngleAxis *arg2 = 0 ;
14240   bool result;
14241
14242   arg1 = (Dali::AngleAxis *)jarg1;
14243   if (!arg1) {
14244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14245     return 0;
14246   }
14247   arg2 = (Dali::AngleAxis *)jarg2;
14248   if (!arg2) {
14249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14250     return 0;
14251   }
14252   {
14253     try {
14254       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14255     } catch (std::out_of_range& e) {
14256       {
14257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14258       };
14259     } catch (std::exception& e) {
14260       {
14261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14262       };
14263     } catch (Dali::DaliException e) {
14264       {
14265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14266       };
14267     } catch (...) {
14268       {
14269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14270       };
14271     }
14272   }
14273
14274   jresult = result;
14275   return jresult;
14276 }
14277
14278
14279 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14280   unsigned int jresult ;
14281   unsigned int arg1 ;
14282   unsigned int result;
14283
14284   arg1 = (unsigned int)jarg1;
14285   {
14286     try {
14287       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14288     } catch (std::out_of_range& e) {
14289       {
14290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14291       };
14292     } catch (std::exception& e) {
14293       {
14294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14295       };
14296     } catch (Dali::DaliException e) {
14297       {
14298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14299       };
14300     } catch (...) {
14301       {
14302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14303       };
14304     }
14305   }
14306
14307   jresult = result;
14308   return jresult;
14309 }
14310
14311
14312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14313   unsigned int jresult ;
14314   unsigned int arg1 ;
14315   bool result;
14316
14317   arg1 = (unsigned int)jarg1;
14318   {
14319     try {
14320       result = (bool)Dali::IsPowerOfTwo(arg1);
14321     } catch (std::out_of_range& e) {
14322       {
14323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14324       };
14325     } catch (std::exception& e) {
14326       {
14327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14328       };
14329     } catch (Dali::DaliException e) {
14330       {
14331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14332       };
14333     } catch (...) {
14334       {
14335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14336       };
14337     }
14338   }
14339
14340   jresult = result;
14341   return jresult;
14342 }
14343
14344
14345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14346   float jresult ;
14347   float arg1 ;
14348   float arg2 ;
14349   float result;
14350
14351   arg1 = (float)jarg1;
14352   arg2 = (float)jarg2;
14353   {
14354     try {
14355       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14356     } catch (std::out_of_range& e) {
14357       {
14358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14359       };
14360     } catch (std::exception& e) {
14361       {
14362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14363       };
14364     } catch (Dali::DaliException e) {
14365       {
14366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14367       };
14368     } catch (...) {
14369       {
14370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14371       };
14372     }
14373   }
14374
14375   jresult = result;
14376   return jresult;
14377 }
14378
14379
14380 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14381   unsigned int jresult ;
14382   float arg1 ;
14383   bool result;
14384
14385   arg1 = (float)jarg1;
14386   {
14387     try {
14388       result = (bool)Dali::EqualsZero(arg1);
14389     } catch (std::out_of_range& e) {
14390       {
14391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14392       };
14393     } catch (std::exception& e) {
14394       {
14395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14396       };
14397     } catch (Dali::DaliException e) {
14398       {
14399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14400       };
14401     } catch (...) {
14402       {
14403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14404       };
14405     }
14406   }
14407
14408   jresult = result;
14409   return jresult;
14410 }
14411
14412
14413 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14414   unsigned int jresult ;
14415   float arg1 ;
14416   float arg2 ;
14417   bool result;
14418
14419   arg1 = (float)jarg1;
14420   arg2 = (float)jarg2;
14421   {
14422     try {
14423       result = (bool)Dali::Equals(arg1,arg2);
14424     } catch (std::out_of_range& e) {
14425       {
14426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14427       };
14428     } catch (std::exception& e) {
14429       {
14430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14431       };
14432     } catch (Dali::DaliException e) {
14433       {
14434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14435       };
14436     } catch (...) {
14437       {
14438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14439       };
14440     }
14441   }
14442
14443   jresult = result;
14444   return jresult;
14445 }
14446
14447
14448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14449   unsigned int jresult ;
14450   float arg1 ;
14451   float arg2 ;
14452   float arg3 ;
14453   bool result;
14454
14455   arg1 = (float)jarg1;
14456   arg2 = (float)jarg2;
14457   arg3 = (float)jarg3;
14458   {
14459     try {
14460       result = (bool)Dali::Equals(arg1,arg2,arg3);
14461     } catch (std::out_of_range& e) {
14462       {
14463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14464       };
14465     } catch (std::exception& e) {
14466       {
14467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14468       };
14469     } catch (Dali::DaliException e) {
14470       {
14471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14472       };
14473     } catch (...) {
14474       {
14475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14476       };
14477     }
14478   }
14479
14480   jresult = result;
14481   return jresult;
14482 }
14483
14484
14485 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14486   float jresult ;
14487   float arg1 ;
14488   int arg2 ;
14489   float result;
14490
14491   arg1 = (float)jarg1;
14492   arg2 = (int)jarg2;
14493   {
14494     try {
14495       result = (float)Dali::Round(arg1,arg2);
14496     } catch (std::out_of_range& e) {
14497       {
14498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14499       };
14500     } catch (std::exception& e) {
14501       {
14502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14503       };
14504     } catch (Dali::DaliException e) {
14505       {
14506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14507       };
14508     } catch (...) {
14509       {
14510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14511       };
14512     }
14513   }
14514
14515   jresult = result;
14516   return jresult;
14517 }
14518
14519
14520 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14521   float jresult ;
14522   float arg1 ;
14523   float arg2 ;
14524   float arg3 ;
14525   float result;
14526
14527   arg1 = (float)jarg1;
14528   arg2 = (float)jarg2;
14529   arg3 = (float)jarg3;
14530   {
14531     try {
14532       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14533     } catch (std::out_of_range& e) {
14534       {
14535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14536       };
14537     } catch (std::exception& e) {
14538       {
14539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14540       };
14541     } catch (Dali::DaliException e) {
14542       {
14543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14544       };
14545     } catch (...) {
14546       {
14547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14548       };
14549     }
14550   }
14551
14552   jresult = result;
14553   return jresult;
14554 }
14555
14556
14557 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14558   float jresult ;
14559   float arg1 ;
14560   float arg2 ;
14561   float arg3 ;
14562   float arg4 ;
14563   float result;
14564
14565   arg1 = (float)jarg1;
14566   arg2 = (float)jarg2;
14567   arg3 = (float)jarg3;
14568   arg4 = (float)jarg4;
14569   {
14570     try {
14571       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14572     } catch (std::out_of_range& e) {
14573       {
14574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14575       };
14576     } catch (std::exception& e) {
14577       {
14578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14579       };
14580     } catch (Dali::DaliException e) {
14581       {
14582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14583       };
14584     } catch (...) {
14585       {
14586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14587       };
14588     }
14589   }
14590
14591   jresult = result;
14592   return jresult;
14593 }
14594
14595
14596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14597   int jresult ;
14598   int result;
14599
14600   result = (int)(int)Dali::Property::INVALID_INDEX;
14601   jresult = result;
14602   return jresult;
14603 }
14604
14605
14606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14607   int jresult ;
14608   int result;
14609
14610   result = (int)(int)Dali::Property::INVALID_KEY;
14611   jresult = result;
14612   return jresult;
14613 }
14614
14615
14616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14617   int jresult ;
14618   int result;
14619
14620   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14621   jresult = result;
14622   return jresult;
14623 }
14624
14625
14626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14627   void * jresult ;
14628   Dali::Handle *arg1 = 0 ;
14629   Dali::Property::Index arg2 ;
14630   Dali::Property *result = 0 ;
14631
14632   arg1 = (Dali::Handle *)jarg1;
14633   if (!arg1) {
14634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14635     return 0;
14636   }
14637   arg2 = (Dali::Property::Index)jarg2;
14638   {
14639     try {
14640       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14641     } catch (std::out_of_range& e) {
14642       {
14643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14644       };
14645     } catch (std::exception& e) {
14646       {
14647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14648       };
14649     } catch (Dali::DaliException e) {
14650       {
14651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14652       };
14653     } catch (...) {
14654       {
14655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14656       };
14657     }
14658   }
14659
14660   jresult = (void *)result;
14661   return jresult;
14662 }
14663
14664
14665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14666   void * jresult ;
14667   Dali::Handle *arg1 = 0 ;
14668   Dali::Property::Index arg2 ;
14669   int arg3 ;
14670   Dali::Property *result = 0 ;
14671
14672   arg1 = (Dali::Handle *)jarg1;
14673   if (!arg1) {
14674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14675     return 0;
14676   }
14677   arg2 = (Dali::Property::Index)jarg2;
14678   arg3 = (int)jarg3;
14679   {
14680     try {
14681       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14682     } catch (std::out_of_range& e) {
14683       {
14684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14685       };
14686     } catch (std::exception& e) {
14687       {
14688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14689       };
14690     } catch (Dali::DaliException e) {
14691       {
14692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14693       };
14694     } catch (...) {
14695       {
14696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14697       };
14698     }
14699   }
14700
14701   jresult = (void *)result;
14702   return jresult;
14703 }
14704
14705
14706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14707   void * jresult ;
14708   Dali::Handle *arg1 = 0 ;
14709   std::string *arg2 = 0 ;
14710   Dali::Property *result = 0 ;
14711
14712   arg1 = (Dali::Handle *)jarg1;
14713   if (!arg1) {
14714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14715     return 0;
14716   }
14717   if (!jarg2) {
14718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14719     return 0;
14720   }
14721   std::string arg2_str(jarg2);
14722   arg2 = &arg2_str;
14723   {
14724     try {
14725       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14726     } catch (std::out_of_range& e) {
14727       {
14728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14729       };
14730     } catch (std::exception& e) {
14731       {
14732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14733       };
14734     } catch (Dali::DaliException e) {
14735       {
14736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14737       };
14738     } catch (...) {
14739       {
14740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14741       };
14742     }
14743   }
14744
14745   jresult = (void *)result;
14746
14747   //argout typemap for const std::string&
14748
14749   return jresult;
14750 }
14751
14752
14753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14754   void * jresult ;
14755   Dali::Handle *arg1 = 0 ;
14756   std::string *arg2 = 0 ;
14757   int arg3 ;
14758   Dali::Property *result = 0 ;
14759
14760   arg1 = (Dali::Handle *)jarg1;
14761   if (!arg1) {
14762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14763     return 0;
14764   }
14765   if (!jarg2) {
14766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14767     return 0;
14768   }
14769   std::string arg2_str(jarg2);
14770   arg2 = &arg2_str;
14771   arg3 = (int)jarg3;
14772   {
14773     try {
14774       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14775     } catch (std::out_of_range& e) {
14776       {
14777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14778       };
14779     } catch (std::exception& e) {
14780       {
14781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14782       };
14783     } catch (Dali::DaliException e) {
14784       {
14785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14786       };
14787     } catch (...) {
14788       {
14789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14790       };
14791     }
14792   }
14793
14794   jresult = (void *)result;
14795
14796   //argout typemap for const std::string&
14797
14798   return jresult;
14799 }
14800
14801
14802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14803   Dali::Property *arg1 = (Dali::Property *) 0 ;
14804
14805   arg1 = (Dali::Property *)jarg1;
14806   {
14807     try {
14808       delete arg1;
14809     } catch (std::out_of_range& e) {
14810       {
14811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14812       };
14813     } catch (std::exception& e) {
14814       {
14815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14816       };
14817     } catch (Dali::DaliException e) {
14818       {
14819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14820       };
14821     } catch (...) {
14822       {
14823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14824       };
14825     }
14826   }
14827
14828 }
14829
14830
14831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14832   Dali::Property *arg1 = (Dali::Property *) 0 ;
14833   Dali::Handle *arg2 = 0 ;
14834
14835   arg1 = (Dali::Property *)jarg1;
14836   arg2 = (Dali::Handle *)jarg2;
14837   if (!arg2) {
14838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14839     return ;
14840   }
14841   if (arg1) (arg1)->object = *arg2;
14842 }
14843
14844
14845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14846   void * jresult ;
14847   Dali::Property *arg1 = (Dali::Property *) 0 ;
14848   Dali::Handle *result = 0 ;
14849
14850   arg1 = (Dali::Property *)jarg1;
14851   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14852   jresult = (void *)result;
14853   return jresult;
14854 }
14855
14856
14857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14858   Dali::Property *arg1 = (Dali::Property *) 0 ;
14859   Dali::Property::Index arg2 ;
14860
14861   arg1 = (Dali::Property *)jarg1;
14862   arg2 = (Dali::Property::Index)jarg2;
14863   if (arg1) (arg1)->propertyIndex = arg2;
14864 }
14865
14866
14867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14868   int jresult ;
14869   Dali::Property *arg1 = (Dali::Property *) 0 ;
14870   Dali::Property::Index result;
14871
14872   arg1 = (Dali::Property *)jarg1;
14873   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14874   jresult = result;
14875   return jresult;
14876 }
14877
14878
14879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14880   Dali::Property *arg1 = (Dali::Property *) 0 ;
14881   int arg2 ;
14882
14883   arg1 = (Dali::Property *)jarg1;
14884   arg2 = (int)jarg2;
14885   if (arg1) (arg1)->componentIndex = arg2;
14886 }
14887
14888
14889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14890   int jresult ;
14891   Dali::Property *arg1 = (Dali::Property *) 0 ;
14892   int result;
14893
14894   arg1 = (Dali::Property *)jarg1;
14895   result = (int) ((arg1)->componentIndex);
14896   jresult = result;
14897   return jresult;
14898 }
14899
14900
14901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14902   void * jresult ;
14903   Dali::Property::Array *result = 0 ;
14904
14905   {
14906     try {
14907       result = (Dali::Property::Array *)new Dali::Property::Array();
14908     } catch (std::out_of_range& e) {
14909       {
14910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14911       };
14912     } catch (std::exception& e) {
14913       {
14914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14915       };
14916     } catch (Dali::DaliException e) {
14917       {
14918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14919       };
14920     } catch (...) {
14921       {
14922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14923       };
14924     }
14925   }
14926
14927   jresult = (void *)result;
14928   return jresult;
14929 }
14930
14931
14932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14933   void * jresult ;
14934   Dali::Property::Array *arg1 = 0 ;
14935   Dali::Property::Array *result = 0 ;
14936
14937   arg1 = (Dali::Property::Array *)jarg1;
14938   if (!arg1) {
14939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14940     return 0;
14941   }
14942   {
14943     try {
14944       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14945     } catch (std::out_of_range& e) {
14946       {
14947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14948       };
14949     } catch (std::exception& e) {
14950       {
14951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14952       };
14953     } catch (Dali::DaliException e) {
14954       {
14955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14956       };
14957     } catch (...) {
14958       {
14959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14960       };
14961     }
14962   }
14963
14964   jresult = (void *)result;
14965   return jresult;
14966 }
14967
14968
14969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14970   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14971
14972   arg1 = (Dali::Property::Array *)jarg1;
14973   {
14974     try {
14975       delete arg1;
14976     } catch (std::out_of_range& e) {
14977       {
14978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14979       };
14980     } catch (std::exception& e) {
14981       {
14982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14983       };
14984     } catch (Dali::DaliException e) {
14985       {
14986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14987       };
14988     } catch (...) {
14989       {
14990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14991       };
14992     }
14993   }
14994
14995 }
14996
14997
14998 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14999   unsigned long jresult ;
15000   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15001   Dali::Property::Array::SizeType result;
15002
15003   arg1 = (Dali::Property::Array *)jarg1;
15004   {
15005     try {
15006       result = ((Dali::Property::Array const *)arg1)->Size();
15007     } catch (std::out_of_range& e) {
15008       {
15009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15010       };
15011     } catch (std::exception& e) {
15012       {
15013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15014       };
15015     } catch (Dali::DaliException e) {
15016       {
15017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15018       };
15019     } catch (...) {
15020       {
15021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15022       };
15023     }
15024   }
15025
15026   jresult = (unsigned long)result;
15027   return jresult;
15028 }
15029
15030
15031 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15032   unsigned long jresult ;
15033   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15034   Dali::Property::Array::SizeType result;
15035
15036   arg1 = (Dali::Property::Array *)jarg1;
15037   {
15038     try {
15039       result = ((Dali::Property::Array const *)arg1)->Count();
15040     } catch (std::out_of_range& e) {
15041       {
15042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15043       };
15044     } catch (std::exception& e) {
15045       {
15046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15047       };
15048     } catch (Dali::DaliException e) {
15049       {
15050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15051       };
15052     } catch (...) {
15053       {
15054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15055       };
15056     }
15057   }
15058
15059   jresult = (unsigned long)result;
15060   return jresult;
15061 }
15062
15063
15064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15065   unsigned int jresult ;
15066   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15067   bool result;
15068
15069   arg1 = (Dali::Property::Array *)jarg1;
15070   {
15071     try {
15072       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15073     } catch (std::out_of_range& e) {
15074       {
15075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15076       };
15077     } catch (std::exception& e) {
15078       {
15079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15080       };
15081     } catch (Dali::DaliException e) {
15082       {
15083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15084       };
15085     } catch (...) {
15086       {
15087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15088       };
15089     }
15090   }
15091
15092   jresult = result;
15093   return jresult;
15094 }
15095
15096
15097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15098   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15099
15100   arg1 = (Dali::Property::Array *)jarg1;
15101   {
15102     try {
15103       (arg1)->Clear();
15104     } catch (std::out_of_range& e) {
15105       {
15106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15107       };
15108     } catch (std::exception& e) {
15109       {
15110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15111       };
15112     } catch (Dali::DaliException e) {
15113       {
15114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15115       };
15116     } catch (...) {
15117       {
15118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15119       };
15120     }
15121   }
15122
15123 }
15124
15125
15126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15127   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15128   Dali::Property::Array::SizeType arg2 ;
15129
15130   arg1 = (Dali::Property::Array *)jarg1;
15131   arg2 = (Dali::Property::Array::SizeType)jarg2;
15132   {
15133     try {
15134       (arg1)->Reserve(arg2);
15135     } catch (std::out_of_range& e) {
15136       {
15137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15138       };
15139     } catch (std::exception& e) {
15140       {
15141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15142       };
15143     } catch (Dali::DaliException e) {
15144       {
15145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15146       };
15147     } catch (...) {
15148       {
15149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15150       };
15151     }
15152   }
15153
15154 }
15155
15156
15157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15158   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15159   Dali::Property::Array::SizeType arg2 ;
15160
15161   arg1 = (Dali::Property::Array *)jarg1;
15162   arg2 = (Dali::Property::Array::SizeType)jarg2;
15163   {
15164     try {
15165       (arg1)->Resize(arg2);
15166     } catch (std::out_of_range& e) {
15167       {
15168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15169       };
15170     } catch (std::exception& e) {
15171       {
15172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15173       };
15174     } catch (Dali::DaliException e) {
15175       {
15176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15177       };
15178     } catch (...) {
15179       {
15180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15181       };
15182     }
15183   }
15184
15185 }
15186
15187
15188 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15189   unsigned long jresult ;
15190   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15191   Dali::Property::Array::SizeType result;
15192
15193   arg1 = (Dali::Property::Array *)jarg1;
15194   {
15195     try {
15196       result = (arg1)->Capacity();
15197     } catch (std::out_of_range& e) {
15198       {
15199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15200       };
15201     } catch (std::exception& e) {
15202       {
15203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15204       };
15205     } catch (Dali::DaliException e) {
15206       {
15207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15208       };
15209     } catch (...) {
15210       {
15211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15212       };
15213     }
15214   }
15215
15216   jresult = (unsigned long)result;
15217   return jresult;
15218 }
15219
15220
15221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15222   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15223   Dali::Property::Value *arg2 = 0 ;
15224
15225   arg1 = (Dali::Property::Array *)jarg1;
15226   arg2 = (Dali::Property::Value *)jarg2;
15227   if (!arg2) {
15228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15229     return ;
15230   }
15231   {
15232     try {
15233       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15234     } catch (std::out_of_range& e) {
15235       {
15236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15237       };
15238     } catch (std::exception& e) {
15239       {
15240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15241       };
15242     } catch (Dali::DaliException e) {
15243       {
15244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15245       };
15246     } catch (...) {
15247       {
15248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15249       };
15250     }
15251   }
15252
15253 }
15254
15255
15256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15257   void * jresult ;
15258   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15259   Dali::Property::Value *arg2 = 0 ;
15260   Dali::Property::Array *result = 0 ;
15261
15262   arg1 = (Dali::Property::Array *)jarg1;
15263   arg2 = (Dali::Property::Value *)jarg2;
15264   if (!arg2) {
15265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15266     return 0;
15267   }
15268   {
15269     try {
15270       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15271     } catch (std::out_of_range& e) {
15272       {
15273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15274       };
15275     } catch (std::exception& e) {
15276       {
15277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15278       };
15279     } catch (Dali::DaliException e) {
15280       {
15281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15282       };
15283     } catch (...) {
15284       {
15285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15286       };
15287     }
15288   }
15289
15290   jresult = (void *)result;
15291   return jresult;
15292 }
15293
15294
15295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15296   void * jresult ;
15297   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15298   Dali::Property::Array::SizeType arg2 ;
15299   Dali::Property::Value *result = 0 ;
15300
15301   arg1 = (Dali::Property::Array *)jarg1;
15302   arg2 = (Dali::Property::Array::SizeType)jarg2;
15303   {
15304     try {
15305       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15306     } catch (std::out_of_range& e) {
15307       {
15308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15309       };
15310     } catch (std::exception& e) {
15311       {
15312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15313       };
15314     } catch (Dali::DaliException e) {
15315       {
15316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15317       };
15318     } catch (...) {
15319       {
15320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15321       };
15322     }
15323   }
15324
15325   jresult = (void *)result;
15326   return jresult;
15327 }
15328
15329
15330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15331   void * jresult ;
15332   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15333   Dali::Property::Array::SizeType arg2 ;
15334   Dali::Property::Value *result = 0 ;
15335
15336   arg1 = (Dali::Property::Array *)jarg1;
15337   arg2 = (Dali::Property::Array::SizeType)jarg2;
15338   {
15339     try {
15340       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15341     } catch (std::out_of_range& e) {
15342       {
15343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15344       };
15345     } catch (std::exception& e) {
15346       {
15347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15348       };
15349     } catch (Dali::DaliException e) {
15350       {
15351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15352       };
15353     } catch (...) {
15354       {
15355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15356       };
15357     }
15358   }
15359
15360   jresult = (void *)result;
15361   return jresult;
15362 }
15363
15364
15365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15366   void * jresult ;
15367   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15368   Dali::Property::Array *arg2 = 0 ;
15369   Dali::Property::Array *result = 0 ;
15370
15371   arg1 = (Dali::Property::Array *)jarg1;
15372   arg2 = (Dali::Property::Array *)jarg2;
15373   if (!arg2) {
15374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15375     return 0;
15376   }
15377   {
15378     try {
15379       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15380     } catch (std::out_of_range& e) {
15381       {
15382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15383       };
15384     } catch (std::exception& e) {
15385       {
15386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15387       };
15388     } catch (Dali::DaliException e) {
15389       {
15390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15391       };
15392     } catch (...) {
15393       {
15394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15395       };
15396     }
15397   }
15398
15399   jresult = (void *)result;
15400   return jresult;
15401 }
15402
15403
15404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15405   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15406   enum Dali::Property::Key::Type arg2 ;
15407
15408   arg1 = (Dali::Property::Key *)jarg1;
15409   arg2 = (enum Dali::Property::Key::Type)jarg2;
15410   if (arg1) (arg1)->type = arg2;
15411 }
15412
15413
15414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15415   int jresult ;
15416   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15417   enum Dali::Property::Key::Type result;
15418
15419   arg1 = (Dali::Property::Key *)jarg1;
15420   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15421   jresult = (int)result;
15422   return jresult;
15423 }
15424
15425
15426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15427   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15428   Dali::Property::Index arg2 ;
15429
15430   arg1 = (Dali::Property::Key *)jarg1;
15431   arg2 = (Dali::Property::Index)jarg2;
15432   if (arg1) (arg1)->indexKey = arg2;
15433 }
15434
15435
15436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15437   int jresult ;
15438   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15439   Dali::Property::Index result;
15440
15441   arg1 = (Dali::Property::Key *)jarg1;
15442   result = (Dali::Property::Index) ((arg1)->indexKey);
15443   jresult = result;
15444   return jresult;
15445 }
15446
15447
15448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15449   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15450   std::string *arg2 = 0 ;
15451
15452   arg1 = (Dali::Property::Key *)jarg1;
15453   if (!jarg2) {
15454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15455     return ;
15456   }
15457   std::string arg2_str(jarg2);
15458   arg2 = &arg2_str;
15459   if (arg1) (arg1)->stringKey = *arg2;
15460
15461   //argout typemap for const std::string&
15462
15463 }
15464
15465
15466 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15467   char * jresult ;
15468   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15469   std::string *result = 0 ;
15470
15471   arg1 = (Dali::Property::Key *)jarg1;
15472   result = (std::string *) & ((arg1)->stringKey);
15473   jresult = SWIG_csharp_string_callback(result->c_str());
15474   return jresult;
15475 }
15476
15477
15478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15479   void * jresult ;
15480   std::string *arg1 = 0 ;
15481   Dali::Property::Key *result = 0 ;
15482
15483   if (!jarg1) {
15484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15485     return 0;
15486   }
15487   std::string arg1_str(jarg1);
15488   arg1 = &arg1_str;
15489   {
15490     try {
15491       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15492     } catch (std::out_of_range& e) {
15493       {
15494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15495       };
15496     } catch (std::exception& e) {
15497       {
15498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15499       };
15500     } catch (Dali::DaliException e) {
15501       {
15502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15503       };
15504     } catch (...) {
15505       {
15506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15507       };
15508     }
15509   }
15510
15511   jresult = (void *)result;
15512
15513   //argout typemap for const std::string&
15514
15515   return jresult;
15516 }
15517
15518
15519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15520   void * jresult ;
15521   Dali::Property::Index arg1 ;
15522   Dali::Property::Key *result = 0 ;
15523
15524   arg1 = (Dali::Property::Index)jarg1;
15525   {
15526     try {
15527       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15528     } catch (std::out_of_range& e) {
15529       {
15530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15531       };
15532     } catch (std::exception& e) {
15533       {
15534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15535       };
15536     } catch (Dali::DaliException e) {
15537       {
15538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15539       };
15540     } catch (...) {
15541       {
15542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15543       };
15544     }
15545   }
15546
15547   jresult = (void *)result;
15548   return jresult;
15549 }
15550
15551
15552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15553   unsigned int jresult ;
15554   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15555   std::string *arg2 = 0 ;
15556   bool result;
15557
15558   arg1 = (Dali::Property::Key *)jarg1;
15559   if (!jarg2) {
15560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15561     return 0;
15562   }
15563   std::string arg2_str(jarg2);
15564   arg2 = &arg2_str;
15565   {
15566     try {
15567       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15568     } catch (std::out_of_range& e) {
15569       {
15570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15571       };
15572     } catch (std::exception& e) {
15573       {
15574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15575       };
15576     } catch (Dali::DaliException e) {
15577       {
15578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15579       };
15580     } catch (...) {
15581       {
15582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15583       };
15584     }
15585   }
15586
15587   jresult = result;
15588
15589   //argout typemap for const std::string&
15590
15591   return jresult;
15592 }
15593
15594
15595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15596   unsigned int jresult ;
15597   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15598   Dali::Property::Index arg2 ;
15599   bool result;
15600
15601   arg1 = (Dali::Property::Key *)jarg1;
15602   arg2 = (Dali::Property::Index)jarg2;
15603   {
15604     try {
15605       result = (bool)(arg1)->operator ==(arg2);
15606     } catch (std::out_of_range& e) {
15607       {
15608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15609       };
15610     } catch (std::exception& e) {
15611       {
15612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15613       };
15614     } catch (Dali::DaliException e) {
15615       {
15616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15617       };
15618     } catch (...) {
15619       {
15620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15621       };
15622     }
15623   }
15624
15625   jresult = result;
15626   return jresult;
15627 }
15628
15629
15630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15631   unsigned int jresult ;
15632   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15633   Dali::Property::Key *arg2 = 0 ;
15634   bool result;
15635
15636   arg1 = (Dali::Property::Key *)jarg1;
15637   arg2 = (Dali::Property::Key *)jarg2;
15638   if (!arg2) {
15639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15640     return 0;
15641   }
15642   {
15643     try {
15644       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15645     } catch (std::out_of_range& e) {
15646       {
15647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15648       };
15649     } catch (std::exception& e) {
15650       {
15651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15652       };
15653     } catch (Dali::DaliException e) {
15654       {
15655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15656       };
15657     } catch (...) {
15658       {
15659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15660       };
15661     }
15662   }
15663
15664   jresult = result;
15665   return jresult;
15666 }
15667
15668
15669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15670   unsigned int jresult ;
15671   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15672   std::string *arg2 = 0 ;
15673   bool result;
15674
15675   arg1 = (Dali::Property::Key *)jarg1;
15676   if (!jarg2) {
15677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15678     return 0;
15679   }
15680   std::string arg2_str(jarg2);
15681   arg2 = &arg2_str;
15682   {
15683     try {
15684       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15685     } catch (std::out_of_range& e) {
15686       {
15687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15688       };
15689     } catch (std::exception& e) {
15690       {
15691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15692       };
15693     } catch (Dali::DaliException e) {
15694       {
15695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15696       };
15697     } catch (...) {
15698       {
15699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15700       };
15701     }
15702   }
15703
15704   jresult = result;
15705
15706   //argout typemap for const std::string&
15707
15708   return jresult;
15709 }
15710
15711
15712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15713   unsigned int jresult ;
15714   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15715   Dali::Property::Index arg2 ;
15716   bool result;
15717
15718   arg1 = (Dali::Property::Key *)jarg1;
15719   arg2 = (Dali::Property::Index)jarg2;
15720   {
15721     try {
15722       result = (bool)(arg1)->operator !=(arg2);
15723     } catch (std::out_of_range& e) {
15724       {
15725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15726       };
15727     } catch (std::exception& e) {
15728       {
15729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15730       };
15731     } catch (Dali::DaliException e) {
15732       {
15733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15734       };
15735     } catch (...) {
15736       {
15737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15738       };
15739     }
15740   }
15741
15742   jresult = result;
15743   return jresult;
15744 }
15745
15746
15747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15748   unsigned int jresult ;
15749   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15750   Dali::Property::Key *arg2 = 0 ;
15751   bool result;
15752
15753   arg1 = (Dali::Property::Key *)jarg1;
15754   arg2 = (Dali::Property::Key *)jarg2;
15755   if (!arg2) {
15756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15757     return 0;
15758   }
15759   {
15760     try {
15761       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15762     } catch (std::out_of_range& e) {
15763       {
15764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15765       };
15766     } catch (std::exception& e) {
15767       {
15768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15769       };
15770     } catch (Dali::DaliException e) {
15771       {
15772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15773       };
15774     } catch (...) {
15775       {
15776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15777       };
15778     }
15779   }
15780
15781   jresult = result;
15782   return jresult;
15783 }
15784
15785
15786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15787   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15788
15789   arg1 = (Dali::Property::Key *)jarg1;
15790   {
15791     try {
15792       delete arg1;
15793     } catch (std::out_of_range& e) {
15794       {
15795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15796       };
15797     } catch (std::exception& e) {
15798       {
15799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15800       };
15801     } catch (Dali::DaliException e) {
15802       {
15803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15804       };
15805     } catch (...) {
15806       {
15807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15808       };
15809     }
15810   }
15811
15812 }
15813
15814
15815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15816   void * jresult ;
15817   Dali::Property::Map *result = 0 ;
15818
15819   {
15820     try {
15821       result = (Dali::Property::Map *)new Dali::Property::Map();
15822     } catch (std::out_of_range& e) {
15823       {
15824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15825       };
15826     } catch (std::exception& e) {
15827       {
15828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15829       };
15830     } catch (Dali::DaliException e) {
15831       {
15832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15833       };
15834     } catch (...) {
15835       {
15836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15837       };
15838     }
15839   }
15840
15841   jresult = (void *)result;
15842   return jresult;
15843 }
15844
15845
15846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15847   void * jresult ;
15848   Dali::Property::Map *arg1 = 0 ;
15849   Dali::Property::Map *result = 0 ;
15850
15851   arg1 = (Dali::Property::Map *)jarg1;
15852   if (!arg1) {
15853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15854     return 0;
15855   }
15856   {
15857     try {
15858       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15859     } catch (std::out_of_range& e) {
15860       {
15861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15862       };
15863     } catch (std::exception& e) {
15864       {
15865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15866       };
15867     } catch (Dali::DaliException e) {
15868       {
15869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15870       };
15871     } catch (...) {
15872       {
15873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15874       };
15875     }
15876   }
15877
15878   jresult = (void *)result;
15879   return jresult;
15880 }
15881
15882
15883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15884   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15885
15886   arg1 = (Dali::Property::Map *)jarg1;
15887   {
15888     try {
15889       delete arg1;
15890     } catch (std::out_of_range& e) {
15891       {
15892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15893       };
15894     } catch (std::exception& e) {
15895       {
15896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15897       };
15898     } catch (Dali::DaliException e) {
15899       {
15900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15901       };
15902     } catch (...) {
15903       {
15904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15905       };
15906     }
15907   }
15908
15909 }
15910
15911
15912 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15913   unsigned long jresult ;
15914   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15915   Dali::Property::Map::SizeType result;
15916
15917   arg1 = (Dali::Property::Map *)jarg1;
15918   {
15919     try {
15920       result = ((Dali::Property::Map const *)arg1)->Count();
15921     } catch (std::out_of_range& e) {
15922       {
15923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15924       };
15925     } catch (std::exception& e) {
15926       {
15927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15928       };
15929     } catch (Dali::DaliException e) {
15930       {
15931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15932       };
15933     } catch (...) {
15934       {
15935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15936       };
15937     }
15938   }
15939
15940   jresult = (unsigned long)result;
15941   return jresult;
15942 }
15943
15944
15945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15946   unsigned int jresult ;
15947   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15948   bool result;
15949
15950   arg1 = (Dali::Property::Map *)jarg1;
15951   {
15952     try {
15953       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15954     } catch (std::out_of_range& e) {
15955       {
15956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15957       };
15958     } catch (std::exception& e) {
15959       {
15960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15961       };
15962     } catch (Dali::DaliException e) {
15963       {
15964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15965       };
15966     } catch (...) {
15967       {
15968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15969       };
15970     }
15971   }
15972
15973   jresult = result;
15974   return jresult;
15975 }
15976
15977
15978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15979   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15980   char *arg2 = (char *) 0 ;
15981   Dali::Property::Value *arg3 = 0 ;
15982
15983   arg1 = (Dali::Property::Map *)jarg1;
15984   arg2 = (char *)jarg2;
15985   arg3 = (Dali::Property::Value *)jarg3;
15986   if (!arg3) {
15987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15988     return ;
15989   }
15990   {
15991     try {
15992       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15993     } catch (std::out_of_range& e) {
15994       {
15995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15996       };
15997     } catch (std::exception& e) {
15998       {
15999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16000       };
16001     } catch (Dali::DaliException e) {
16002       {
16003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16004       };
16005     } catch (...) {
16006       {
16007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16008       };
16009     }
16010   }
16011
16012 }
16013
16014
16015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16016   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16017   Dali::Property::Index arg2 ;
16018   Dali::Property::Value *arg3 = 0 ;
16019
16020   arg1 = (Dali::Property::Map *)jarg1;
16021   arg2 = (Dali::Property::Index)jarg2;
16022   arg3 = (Dali::Property::Value *)jarg3;
16023   if (!arg3) {
16024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16025     return ;
16026   }
16027   {
16028     try {
16029       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16030     } catch (std::out_of_range& e) {
16031       {
16032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16033       };
16034     } catch (std::exception& e) {
16035       {
16036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16037       };
16038     } catch (Dali::DaliException e) {
16039       {
16040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16041       };
16042     } catch (...) {
16043       {
16044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16045       };
16046     }
16047   }
16048
16049 }
16050
16051
16052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16053   void * jresult ;
16054   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16055   char *arg2 = (char *) 0 ;
16056   Dali::Property::Value *arg3 = 0 ;
16057   Dali::Property::Map *result = 0 ;
16058
16059   arg1 = (Dali::Property::Map *)jarg1;
16060   arg2 = (char *)jarg2;
16061   arg3 = (Dali::Property::Value *)jarg3;
16062   if (!arg3) {
16063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16064     return 0;
16065   }
16066   {
16067     try {
16068       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16069     } catch (std::out_of_range& e) {
16070       {
16071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16072       };
16073     } catch (std::exception& e) {
16074       {
16075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16076       };
16077     } catch (Dali::DaliException e) {
16078       {
16079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16080       };
16081     } catch (...) {
16082       {
16083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16084       };
16085     }
16086   }
16087
16088   jresult = (void *)result;
16089   return jresult;
16090 }
16091
16092
16093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16094   void * jresult ;
16095   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16096   Dali::Property::Index arg2 ;
16097   Dali::Property::Value *arg3 = 0 ;
16098   Dali::Property::Map *result = 0 ;
16099
16100   arg1 = (Dali::Property::Map *)jarg1;
16101   arg2 = (Dali::Property::Index)jarg2;
16102   arg3 = (Dali::Property::Value *)jarg3;
16103   if (!arg3) {
16104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16105     return 0;
16106   }
16107   {
16108     try {
16109       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16110     } catch (std::out_of_range& e) {
16111       {
16112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16113       };
16114     } catch (std::exception& e) {
16115       {
16116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16117       };
16118     } catch (Dali::DaliException e) {
16119       {
16120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16121       };
16122     } catch (...) {
16123       {
16124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16125       };
16126     }
16127   }
16128
16129   jresult = (void *)result;
16130   return jresult;
16131 }
16132
16133
16134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16135   void * jresult ;
16136   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16137   Dali::Property::Map::SizeType arg2 ;
16138   Dali::Property::Value *result = 0 ;
16139
16140   arg1 = (Dali::Property::Map *)jarg1;
16141   arg2 = (Dali::Property::Map::SizeType)jarg2;
16142   {
16143     try {
16144       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16145     } catch (std::out_of_range& e) {
16146       {
16147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16148       };
16149     } catch (std::exception& e) {
16150       {
16151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16152       };
16153     } catch (Dali::DaliException e) {
16154       {
16155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16156       };
16157     } catch (...) {
16158       {
16159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16160       };
16161     }
16162   }
16163
16164   jresult = (void *)result;
16165   return jresult;
16166 }
16167
16168
16169 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16170   char * jresult ;
16171   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16172   Dali::Property::Map::SizeType arg2 ;
16173   std::string *result = 0 ;
16174
16175   arg1 = (Dali::Property::Map *)jarg1;
16176   arg2 = (Dali::Property::Map::SizeType)jarg2;
16177   {
16178     try {
16179       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16180     } catch (std::out_of_range& e) {
16181       {
16182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16183       };
16184     } catch (std::exception& e) {
16185       {
16186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16187       };
16188     } catch (Dali::DaliException e) {
16189       {
16190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16191       };
16192     } catch (...) {
16193       {
16194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16195       };
16196     }
16197   }
16198
16199   jresult = SWIG_csharp_string_callback(result->c_str());
16200   return jresult;
16201 }
16202
16203
16204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16205   void * jresult ;
16206   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16207   Dali::Property::Map::SizeType arg2 ;
16208   SwigValueWrapper< Dali::Property::Key > result;
16209
16210   arg1 = (Dali::Property::Map *)jarg1;
16211   arg2 = (Dali::Property::Map::SizeType)jarg2;
16212   {
16213     try {
16214       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16215     } catch (std::out_of_range& e) {
16216       {
16217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16218       };
16219     } catch (std::exception& e) {
16220       {
16221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16222       };
16223     } catch (Dali::DaliException e) {
16224       {
16225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16226       };
16227     } catch (...) {
16228       {
16229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16230       };
16231     }
16232   }
16233
16234   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16235   return jresult;
16236 }
16237
16238
16239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16240   void * jresult ;
16241   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16242   Dali::Property::Map::SizeType arg2 ;
16243   StringValuePair *result = 0 ;
16244
16245   arg1 = (Dali::Property::Map *)jarg1;
16246   arg2 = (Dali::Property::Map::SizeType)jarg2;
16247   {
16248     try {
16249       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16250     } catch (std::out_of_range& e) {
16251       {
16252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16253       };
16254     } catch (std::exception& e) {
16255       {
16256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16257       };
16258     } catch (Dali::DaliException e) {
16259       {
16260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16261       };
16262     } catch (...) {
16263       {
16264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16265       };
16266     }
16267   }
16268
16269   jresult = (void *)result;
16270   return jresult;
16271 }
16272
16273
16274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16275   void * jresult ;
16276   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16277   char *arg2 = (char *) 0 ;
16278   Dali::Property::Value *result = 0 ;
16279
16280   arg1 = (Dali::Property::Map *)jarg1;
16281   arg2 = (char *)jarg2;
16282   {
16283     try {
16284       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16285     } catch (std::out_of_range& e) {
16286       {
16287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16288       };
16289     } catch (std::exception& e) {
16290       {
16291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16292       };
16293     } catch (Dali::DaliException e) {
16294       {
16295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16296       };
16297     } catch (...) {
16298       {
16299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16300       };
16301     }
16302   }
16303
16304   jresult = (void *)result;
16305   return jresult;
16306 }
16307
16308
16309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16310   void * jresult ;
16311   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16312   Dali::Property::Index arg2 ;
16313   Dali::Property::Value *result = 0 ;
16314
16315   arg1 = (Dali::Property::Map *)jarg1;
16316   arg2 = (Dali::Property::Index)jarg2;
16317   {
16318     try {
16319       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16320     } catch (std::out_of_range& e) {
16321       {
16322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16323       };
16324     } catch (std::exception& e) {
16325       {
16326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16327       };
16328     } catch (Dali::DaliException e) {
16329       {
16330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16331       };
16332     } catch (...) {
16333       {
16334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16335       };
16336     }
16337   }
16338
16339   jresult = (void *)result;
16340   return jresult;
16341 }
16342
16343
16344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16345   void * jresult ;
16346   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16347   Dali::Property::Index arg2 ;
16348   std::string *arg3 = 0 ;
16349   Dali::Property::Value *result = 0 ;
16350
16351   arg1 = (Dali::Property::Map *)jarg1;
16352   arg2 = (Dali::Property::Index)jarg2;
16353   if (!jarg3) {
16354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16355     return 0;
16356   }
16357   std::string arg3_str(jarg3);
16358   arg3 = &arg3_str;
16359   {
16360     try {
16361       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16362     } catch (std::out_of_range& e) {
16363       {
16364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16365       };
16366     } catch (std::exception& e) {
16367       {
16368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16369       };
16370     } catch (Dali::DaliException e) {
16371       {
16372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16373       };
16374     } catch (...) {
16375       {
16376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16377       };
16378     }
16379   }
16380
16381   jresult = (void *)result;
16382
16383   //argout typemap for const std::string&
16384
16385   return jresult;
16386 }
16387
16388
16389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16390   void * jresult ;
16391   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16392   std::string *arg2 = 0 ;
16393   Dali::Property::Type arg3 ;
16394   Dali::Property::Value *result = 0 ;
16395
16396   arg1 = (Dali::Property::Map *)jarg1;
16397   if (!jarg2) {
16398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16399     return 0;
16400   }
16401   std::string arg2_str(jarg2);
16402   arg2 = &arg2_str;
16403   arg3 = (Dali::Property::Type)jarg3;
16404   {
16405     try {
16406       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16407     } catch (std::out_of_range& e) {
16408       {
16409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16410       };
16411     } catch (std::exception& e) {
16412       {
16413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16414       };
16415     } catch (Dali::DaliException e) {
16416       {
16417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16418       };
16419     } catch (...) {
16420       {
16421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16422       };
16423     }
16424   }
16425
16426   jresult = (void *)result;
16427
16428   //argout typemap for const std::string&
16429
16430   return jresult;
16431 }
16432
16433
16434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16435   void * jresult ;
16436   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16437   Dali::Property::Index arg2 ;
16438   Dali::Property::Type arg3 ;
16439   Dali::Property::Value *result = 0 ;
16440
16441   arg1 = (Dali::Property::Map *)jarg1;
16442   arg2 = (Dali::Property::Index)jarg2;
16443   arg3 = (Dali::Property::Type)jarg3;
16444   {
16445     try {
16446       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16447     } catch (std::out_of_range& e) {
16448       {
16449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16450       };
16451     } catch (std::exception& e) {
16452       {
16453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16454       };
16455     } catch (Dali::DaliException e) {
16456       {
16457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16458       };
16459     } catch (...) {
16460       {
16461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16462       };
16463     }
16464   }
16465
16466   jresult = (void *)result;
16467   return jresult;
16468 }
16469
16470
16471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16472   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16473
16474   arg1 = (Dali::Property::Map *)jarg1;
16475   {
16476     try {
16477       (arg1)->Clear();
16478     } catch (std::out_of_range& e) {
16479       {
16480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16481       };
16482     } catch (std::exception& e) {
16483       {
16484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16485       };
16486     } catch (Dali::DaliException e) {
16487       {
16488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16489       };
16490     } catch (...) {
16491       {
16492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16493       };
16494     }
16495   }
16496
16497 }
16498
16499
16500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16501   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16502   Dali::Property::Map *arg2 = 0 ;
16503
16504   arg1 = (Dali::Property::Map *)jarg1;
16505   arg2 = (Dali::Property::Map *)jarg2;
16506   if (!arg2) {
16507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16508     return ;
16509   }
16510   {
16511     try {
16512       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16513     } catch (std::out_of_range& e) {
16514       {
16515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16516       };
16517     } catch (std::exception& e) {
16518       {
16519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16520       };
16521     } catch (Dali::DaliException e) {
16522       {
16523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16524       };
16525     } catch (...) {
16526       {
16527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16528       };
16529     }
16530   }
16531
16532 }
16533
16534
16535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16536   void * jresult ;
16537   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16538   std::string *arg2 = 0 ;
16539   Dali::Property::Value *result = 0 ;
16540
16541   arg1 = (Dali::Property::Map *)jarg1;
16542   if (!jarg2) {
16543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16544     return 0;
16545   }
16546   std::string arg2_str(jarg2);
16547   arg2 = &arg2_str;
16548   {
16549     try {
16550       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16551     } catch (std::out_of_range& e) {
16552       {
16553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16554       };
16555     } catch (std::exception& e) {
16556       {
16557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16558       };
16559     } catch (Dali::DaliException e) {
16560       {
16561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16562       };
16563     } catch (...) {
16564       {
16565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16566       };
16567     }
16568   }
16569
16570   jresult = (void *)result;
16571
16572   //argout typemap for const std::string&
16573
16574   return jresult;
16575 }
16576
16577
16578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16579   void * jresult ;
16580   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16581   Dali::Property::Index arg2 ;
16582   Dali::Property::Value *result = 0 ;
16583
16584   arg1 = (Dali::Property::Map *)jarg1;
16585   arg2 = (Dali::Property::Index)jarg2;
16586   {
16587     try {
16588       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16589     } catch (std::out_of_range& e) {
16590       {
16591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16592       };
16593     } catch (std::exception& e) {
16594       {
16595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16596       };
16597     } catch (Dali::DaliException e) {
16598       {
16599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16600       };
16601     } catch (...) {
16602       {
16603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16604       };
16605     }
16606   }
16607
16608   jresult = (void *)result;
16609   return jresult;
16610 }
16611
16612
16613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16614   void * jresult ;
16615   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16616   Dali::Property::Map *arg2 = 0 ;
16617   Dali::Property::Map *result = 0 ;
16618
16619   arg1 = (Dali::Property::Map *)jarg1;
16620   arg2 = (Dali::Property::Map *)jarg2;
16621   if (!arg2) {
16622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16623     return 0;
16624   }
16625   {
16626     try {
16627       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16628     } catch (std::out_of_range& e) {
16629       {
16630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16631       };
16632     } catch (std::exception& e) {
16633       {
16634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16635       };
16636     } catch (Dali::DaliException e) {
16637       {
16638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16639       };
16640     } catch (...) {
16641       {
16642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16643       };
16644     }
16645   }
16646
16647   jresult = (void *)result;
16648   return jresult;
16649 }
16650
16651
16652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
16653
16654   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16655
16656   if (!jarg2) {
16657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16658     return;
16659   }
16660   std::string arg2_str(jarg2);
16661   std::string* arg2 = &arg2_str;
16662
16663   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16664
16665   {
16666     try {
16667       arg1->operator[]((std::string const &)*arg2) = *arg3;
16668     } catch (std::out_of_range& e) {
16669       {
16670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16671       };
16672     } catch (std::exception& e) {
16673       {
16674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16675       };
16676     } catch (Dali::DaliException e) {
16677       {
16678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16679       };
16680     } catch (...) {
16681       {
16682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16683       };
16684     }
16685   }
16686 }
16687
16688
16689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
16690
16691   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16692   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
16693   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16694
16695   {
16696     try {
16697       arg1->operator[](arg2) = *arg3;
16698     } catch (std::out_of_range& e) {
16699       {
16700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16701       };
16702     } catch (std::exception& e) {
16703       {
16704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16705       };
16706     } catch (Dali::DaliException e) {
16707       {
16708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16709       };
16710     } catch (...) {
16711       {
16712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16713       };
16714     }
16715   }
16716 }
16717
16718
16719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16720   void * jresult ;
16721   Dali::Property::Value *result = 0 ;
16722
16723   {
16724     try {
16725       result = (Dali::Property::Value *)new Dali::Property::Value();
16726     } catch (std::out_of_range& e) {
16727       {
16728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16729       };
16730     } catch (std::exception& e) {
16731       {
16732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16733       };
16734     } catch (Dali::DaliException e) {
16735       {
16736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16737       };
16738     } catch (...) {
16739       {
16740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16741       };
16742     }
16743   }
16744
16745   jresult = (void *)result;
16746   return jresult;
16747 }
16748
16749
16750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16751   void * jresult ;
16752   bool arg1 ;
16753   Dali::Property::Value *result = 0 ;
16754
16755   arg1 = jarg1 ? true : false;
16756   {
16757     try {
16758       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16759     } catch (std::out_of_range& e) {
16760       {
16761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16762       };
16763     } catch (std::exception& e) {
16764       {
16765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16766       };
16767     } catch (Dali::DaliException e) {
16768       {
16769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16770       };
16771     } catch (...) {
16772       {
16773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16774       };
16775     }
16776   }
16777
16778   jresult = (void *)result;
16779   return jresult;
16780 }
16781
16782
16783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16784   void * jresult ;
16785   int arg1 ;
16786   Dali::Property::Value *result = 0 ;
16787
16788   arg1 = (int)jarg1;
16789   {
16790     try {
16791       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16792     } catch (std::out_of_range& e) {
16793       {
16794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16795       };
16796     } catch (std::exception& e) {
16797       {
16798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16799       };
16800     } catch (Dali::DaliException e) {
16801       {
16802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16803       };
16804     } catch (...) {
16805       {
16806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16807       };
16808     }
16809   }
16810
16811   jresult = (void *)result;
16812   return jresult;
16813 }
16814
16815
16816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16817   void * jresult ;
16818   float arg1 ;
16819   Dali::Property::Value *result = 0 ;
16820
16821   arg1 = (float)jarg1;
16822   {
16823     try {
16824       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16825     } catch (std::out_of_range& e) {
16826       {
16827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16828       };
16829     } catch (std::exception& e) {
16830       {
16831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16832       };
16833     } catch (Dali::DaliException e) {
16834       {
16835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16836       };
16837     } catch (...) {
16838       {
16839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16840       };
16841     }
16842   }
16843
16844   jresult = (void *)result;
16845   return jresult;
16846 }
16847
16848
16849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16850   void * jresult ;
16851   Dali::Vector2 *arg1 = 0 ;
16852   Dali::Property::Value *result = 0 ;
16853
16854   arg1 = (Dali::Vector2 *)jarg1;
16855   if (!arg1) {
16856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16857     return 0;
16858   }
16859   {
16860     try {
16861       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16862     } catch (std::out_of_range& e) {
16863       {
16864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16865       };
16866     } catch (std::exception& e) {
16867       {
16868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16869       };
16870     } catch (Dali::DaliException e) {
16871       {
16872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16873       };
16874     } catch (...) {
16875       {
16876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16877       };
16878     }
16879   }
16880
16881   jresult = (void *)result;
16882   return jresult;
16883 }
16884
16885
16886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16887   void * jresult ;
16888   Dali::Vector3 *arg1 = 0 ;
16889   Dali::Property::Value *result = 0 ;
16890
16891   arg1 = (Dali::Vector3 *)jarg1;
16892   if (!arg1) {
16893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16894     return 0;
16895   }
16896   {
16897     try {
16898       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16899     } catch (std::out_of_range& e) {
16900       {
16901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16902       };
16903     } catch (std::exception& e) {
16904       {
16905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16906       };
16907     } catch (Dali::DaliException e) {
16908       {
16909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16910       };
16911     } catch (...) {
16912       {
16913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16914       };
16915     }
16916   }
16917
16918   jresult = (void *)result;
16919   return jresult;
16920 }
16921
16922
16923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16924   void * jresult ;
16925   Dali::Vector4 *arg1 = 0 ;
16926   Dali::Property::Value *result = 0 ;
16927
16928   arg1 = (Dali::Vector4 *)jarg1;
16929   if (!arg1) {
16930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16931     return 0;
16932   }
16933   {
16934     try {
16935       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16936     } catch (std::out_of_range& e) {
16937       {
16938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16939       };
16940     } catch (std::exception& e) {
16941       {
16942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16943       };
16944     } catch (Dali::DaliException e) {
16945       {
16946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16947       };
16948     } catch (...) {
16949       {
16950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16951       };
16952     }
16953   }
16954
16955   jresult = (void *)result;
16956   return jresult;
16957 }
16958
16959
16960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16961   void * jresult ;
16962   Dali::Matrix3 *arg1 = 0 ;
16963   Dali::Property::Value *result = 0 ;
16964
16965   arg1 = (Dali::Matrix3 *)jarg1;
16966   if (!arg1) {
16967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16968     return 0;
16969   }
16970   {
16971     try {
16972       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16973     } catch (std::out_of_range& e) {
16974       {
16975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16976       };
16977     } catch (std::exception& e) {
16978       {
16979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16980       };
16981     } catch (Dali::DaliException e) {
16982       {
16983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16984       };
16985     } catch (...) {
16986       {
16987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16988       };
16989     }
16990   }
16991
16992   jresult = (void *)result;
16993   return jresult;
16994 }
16995
16996
16997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16998   void * jresult ;
16999   Dali::Matrix *arg1 = 0 ;
17000   Dali::Property::Value *result = 0 ;
17001
17002   arg1 = (Dali::Matrix *)jarg1;
17003   if (!arg1) {
17004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
17005     return 0;
17006   }
17007   {
17008     try {
17009       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
17010     } catch (std::out_of_range& e) {
17011       {
17012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17013       };
17014     } catch (std::exception& e) {
17015       {
17016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17017       };
17018     } catch (Dali::DaliException e) {
17019       {
17020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17021       };
17022     } catch (...) {
17023       {
17024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17025       };
17026     }
17027   }
17028
17029   jresult = (void *)result;
17030   return jresult;
17031 }
17032
17033
17034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
17035   void * jresult ;
17036   Dali::Rect< int > *arg1 = 0 ;
17037   Dali::Property::Value *result = 0 ;
17038
17039   arg1 = (Dali::Rect< int > *)jarg1;
17040   if (!arg1) {
17041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
17042     return 0;
17043   }
17044   {
17045     try {
17046       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
17047     } catch (std::out_of_range& e) {
17048       {
17049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17050       };
17051     } catch (std::exception& e) {
17052       {
17053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17054       };
17055     } catch (Dali::DaliException e) {
17056       {
17057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17058       };
17059     } catch (...) {
17060       {
17061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17062       };
17063     }
17064   }
17065
17066   jresult = (void *)result;
17067   return jresult;
17068 }
17069
17070
17071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
17072   void * jresult ;
17073   Dali::AngleAxis *arg1 = 0 ;
17074   Dali::Property::Value *result = 0 ;
17075
17076   arg1 = (Dali::AngleAxis *)jarg1;
17077   if (!arg1) {
17078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17079     return 0;
17080   }
17081   {
17082     try {
17083       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17084     } catch (std::out_of_range& e) {
17085       {
17086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17087       };
17088     } catch (std::exception& e) {
17089       {
17090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17091       };
17092     } catch (Dali::DaliException e) {
17093       {
17094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17095       };
17096     } catch (...) {
17097       {
17098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17099       };
17100     }
17101   }
17102
17103   jresult = (void *)result;
17104   return jresult;
17105 }
17106
17107
17108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17109   void * jresult ;
17110   Dali::Quaternion *arg1 = 0 ;
17111   Dali::Property::Value *result = 0 ;
17112
17113   arg1 = (Dali::Quaternion *)jarg1;
17114   if (!arg1) {
17115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17116     return 0;
17117   }
17118   {
17119     try {
17120       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17121     } catch (std::out_of_range& e) {
17122       {
17123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17124       };
17125     } catch (std::exception& e) {
17126       {
17127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17128       };
17129     } catch (Dali::DaliException e) {
17130       {
17131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17132       };
17133     } catch (...) {
17134       {
17135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17136       };
17137     }
17138   }
17139
17140   jresult = (void *)result;
17141   return jresult;
17142 }
17143
17144
17145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17146   void * jresult ;
17147   std::string *arg1 = 0 ;
17148   Dali::Property::Value *result = 0 ;
17149
17150   if (!jarg1) {
17151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17152     return 0;
17153   }
17154   std::string arg1_str(jarg1);
17155   arg1 = &arg1_str;
17156   {
17157     try {
17158       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17159     } catch (std::out_of_range& e) {
17160       {
17161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17162       };
17163     } catch (std::exception& e) {
17164       {
17165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17166       };
17167     } catch (Dali::DaliException e) {
17168       {
17169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17170       };
17171     } catch (...) {
17172       {
17173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17174       };
17175     }
17176   }
17177
17178   jresult = (void *)result;
17179
17180   //argout typemap for const std::string&
17181
17182   return jresult;
17183 }
17184
17185
17186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17187   void * jresult ;
17188   Dali::Property::Array *arg1 = 0 ;
17189   Dali::Property::Value *result = 0 ;
17190
17191   arg1 = (Dali::Property::Array *)jarg1;
17192   if (!arg1) {
17193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17194     return 0;
17195   }
17196   {
17197     try {
17198       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17199     } catch (std::out_of_range& e) {
17200       {
17201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17202       };
17203     } catch (std::exception& e) {
17204       {
17205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17206       };
17207     } catch (Dali::DaliException e) {
17208       {
17209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17210       };
17211     } catch (...) {
17212       {
17213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17214       };
17215     }
17216   }
17217
17218   jresult = (void *)result;
17219   return jresult;
17220 }
17221
17222
17223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17224   void * jresult ;
17225   Dali::Property::Map *arg1 = 0 ;
17226   Dali::Property::Value *result = 0 ;
17227
17228   arg1 = (Dali::Property::Map *)jarg1;
17229   if (!arg1) {
17230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17231     return 0;
17232   }
17233   {
17234     try {
17235       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17236     } catch (std::out_of_range& e) {
17237       {
17238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17239       };
17240     } catch (std::exception& e) {
17241       {
17242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17243       };
17244     } catch (Dali::DaliException e) {
17245       {
17246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17247       };
17248     } catch (...) {
17249       {
17250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17251       };
17252     }
17253   }
17254
17255   jresult = (void *)result;
17256   return jresult;
17257 }
17258
17259
17260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17261   void * jresult ;
17262   Extents *arg1 = 0 ;
17263   Dali::Property::Value *result = 0 ;
17264
17265   arg1 = (Extents *)jarg1;
17266   if (!arg1) {
17267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17268     return 0;
17269   }
17270   {
17271     try {
17272       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17273     } catch (std::out_of_range& e) {
17274       {
17275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17276       };
17277     } catch (std::exception& e) {
17278       {
17279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17280       };
17281     } catch (...) {
17282       {
17283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17284       };
17285     }
17286   }
17287   jresult = (void *)result;
17288   return jresult;
17289 }
17290
17291
17292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17293   void * jresult ;
17294   Dali::Property::Type arg1 ;
17295   Dali::Property::Value *result = 0 ;
17296
17297   arg1 = (Dali::Property::Type)jarg1;
17298   {
17299     try {
17300       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17301     } catch (std::out_of_range& e) {
17302       {
17303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17304       };
17305     } catch (std::exception& e) {
17306       {
17307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17308       };
17309     } catch (Dali::DaliException e) {
17310       {
17311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17312       };
17313     } catch (...) {
17314       {
17315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17316       };
17317     }
17318   }
17319
17320   jresult = (void *)result;
17321   return jresult;
17322 }
17323
17324
17325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17326   void * jresult ;
17327   Dali::Property::Value *arg1 = 0 ;
17328   Dali::Property::Value *result = 0 ;
17329
17330   arg1 = (Dali::Property::Value *)jarg1;
17331   if (!arg1) {
17332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17333     return 0;
17334   }
17335   {
17336     try {
17337       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17338     } catch (std::out_of_range& e) {
17339       {
17340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17341       };
17342     } catch (std::exception& e) {
17343       {
17344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17345       };
17346     } catch (Dali::DaliException e) {
17347       {
17348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17349       };
17350     } catch (...) {
17351       {
17352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17353       };
17354     }
17355   }
17356
17357   jresult = (void *)result;
17358   return jresult;
17359 }
17360
17361
17362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17363   void * jresult ;
17364   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17365   Dali::Property::Value *arg2 = 0 ;
17366   Dali::Property::Value *result = 0 ;
17367
17368   arg1 = (Dali::Property::Value *)jarg1;
17369   arg2 = (Dali::Property::Value *)jarg2;
17370   if (!arg2) {
17371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17372     return 0;
17373   }
17374   {
17375     try {
17376       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17377     } catch (std::out_of_range& e) {
17378       {
17379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17380       };
17381     } catch (std::exception& e) {
17382       {
17383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17384       };
17385     } catch (Dali::DaliException e) {
17386       {
17387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17388       };
17389     } catch (...) {
17390       {
17391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17392       };
17393     }
17394   }
17395
17396   jresult = (void *)result;
17397   return jresult;
17398 }
17399
17400
17401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17402   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17403
17404   arg1 = (Dali::Property::Value *)jarg1;
17405   {
17406     try {
17407       delete arg1;
17408     } catch (std::out_of_range& e) {
17409       {
17410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17411       };
17412     } catch (std::exception& e) {
17413       {
17414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17415       };
17416     } catch (Dali::DaliException e) {
17417       {
17418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17419       };
17420     } catch (...) {
17421       {
17422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17423       };
17424     }
17425   }
17426
17427 }
17428
17429
17430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17431   int jresult ;
17432   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17433   Dali::Property::Type result;
17434
17435   arg1 = (Dali::Property::Value *)jarg1;
17436   {
17437     try {
17438       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17439     } catch (std::out_of_range& e) {
17440       {
17441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17442       };
17443     } catch (std::exception& e) {
17444       {
17445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17446       };
17447     } catch (Dali::DaliException e) {
17448       {
17449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17450       };
17451     } catch (...) {
17452       {
17453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17454       };
17455     }
17456   }
17457
17458   jresult = (int)result;
17459   return jresult;
17460 }
17461
17462
17463 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17464   unsigned int jresult ;
17465   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17466   bool *arg2 = 0 ;
17467   bool result;
17468
17469   arg1 = (Dali::Property::Value *)jarg1;
17470   arg2 = (bool *)jarg2;
17471   {
17472     try {
17473       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17474     } catch (std::out_of_range& e) {
17475       {
17476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17477       };
17478     } catch (std::exception& e) {
17479       {
17480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17481       };
17482     } catch (Dali::DaliException e) {
17483       {
17484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17485       };
17486     } catch (...) {
17487       {
17488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17489       };
17490     }
17491   }
17492
17493   jresult = result;
17494   return jresult;
17495 }
17496
17497
17498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17499   unsigned int jresult ;
17500   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17501   float *arg2 = 0 ;
17502   bool result;
17503
17504   arg1 = (Dali::Property::Value *)jarg1;
17505   arg2 = (float *)jarg2;
17506   {
17507     try {
17508       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17509     } catch (std::out_of_range& e) {
17510       {
17511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17512       };
17513     } catch (std::exception& e) {
17514       {
17515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17516       };
17517     } catch (Dali::DaliException e) {
17518       {
17519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17520       };
17521     } catch (...) {
17522       {
17523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17524       };
17525     }
17526   }
17527
17528   jresult = result;
17529   return jresult;
17530 }
17531
17532
17533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17534   unsigned int jresult ;
17535   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17536   int *arg2 = 0 ;
17537   bool result;
17538
17539   arg1 = (Dali::Property::Value *)jarg1;
17540   arg2 = (int *)jarg2;
17541   {
17542     try {
17543       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17544     } catch (std::out_of_range& e) {
17545       {
17546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17547       };
17548     } catch (std::exception& e) {
17549       {
17550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17551       };
17552     } catch (Dali::DaliException e) {
17553       {
17554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17555       };
17556     } catch (...) {
17557       {
17558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17559       };
17560     }
17561   }
17562
17563   jresult = result;
17564   return jresult;
17565 }
17566
17567
17568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17569   unsigned int jresult ;
17570   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17571   Dali::Rect< int > *arg2 = 0 ;
17572   bool result;
17573
17574   arg1 = (Dali::Property::Value *)jarg1;
17575   arg2 = (Dali::Rect< int > *)jarg2;
17576   if (!arg2) {
17577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17578     return 0;
17579   }
17580   {
17581     try {
17582       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17583     } catch (std::out_of_range& e) {
17584       {
17585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17586       };
17587     } catch (std::exception& e) {
17588       {
17589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17590       };
17591     } catch (Dali::DaliException e) {
17592       {
17593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17594       };
17595     } catch (...) {
17596       {
17597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17598       };
17599     }
17600   }
17601
17602   jresult = result;
17603   return jresult;
17604 }
17605
17606
17607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17608   unsigned int jresult ;
17609   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17610   Dali::Vector2 *arg2 = 0 ;
17611   bool result;
17612
17613   arg1 = (Dali::Property::Value *)jarg1;
17614   arg2 = (Dali::Vector2 *)jarg2;
17615   if (!arg2) {
17616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17617     return 0;
17618   }
17619   {
17620     try {
17621       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17622     } catch (std::out_of_range& e) {
17623       {
17624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17625       };
17626     } catch (std::exception& e) {
17627       {
17628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17629       };
17630     } catch (Dali::DaliException e) {
17631       {
17632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17633       };
17634     } catch (...) {
17635       {
17636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17637       };
17638     }
17639   }
17640
17641   jresult = result;
17642   return jresult;
17643 }
17644
17645
17646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17647   unsigned int jresult ;
17648   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17649   Dali::Vector3 *arg2 = 0 ;
17650   bool result;
17651
17652   arg1 = (Dali::Property::Value *)jarg1;
17653   arg2 = (Dali::Vector3 *)jarg2;
17654   if (!arg2) {
17655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17656     return 0;
17657   }
17658   {
17659     try {
17660       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17661     } catch (std::out_of_range& e) {
17662       {
17663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17664       };
17665     } catch (std::exception& e) {
17666       {
17667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17668       };
17669     } catch (Dali::DaliException e) {
17670       {
17671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17672       };
17673     } catch (...) {
17674       {
17675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17676       };
17677     }
17678   }
17679
17680   jresult = result;
17681   return jresult;
17682 }
17683
17684
17685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17686   unsigned int jresult ;
17687   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17688   Dali::Vector4 *arg2 = 0 ;
17689   bool result;
17690
17691   arg1 = (Dali::Property::Value *)jarg1;
17692   arg2 = (Dali::Vector4 *)jarg2;
17693   if (!arg2) {
17694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17695     return 0;
17696   }
17697   {
17698     try {
17699       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17700     } catch (std::out_of_range& e) {
17701       {
17702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17703       };
17704     } catch (std::exception& e) {
17705       {
17706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17707       };
17708     } catch (Dali::DaliException e) {
17709       {
17710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17711       };
17712     } catch (...) {
17713       {
17714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17715       };
17716     }
17717   }
17718
17719   jresult = result;
17720   return jresult;
17721 }
17722
17723
17724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17725   unsigned int jresult ;
17726   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17727   Dali::Matrix3 *arg2 = 0 ;
17728   bool result;
17729
17730   arg1 = (Dali::Property::Value *)jarg1;
17731   arg2 = (Dali::Matrix3 *)jarg2;
17732   if (!arg2) {
17733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17734     return 0;
17735   }
17736   {
17737     try {
17738       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17739     } catch (std::out_of_range& e) {
17740       {
17741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17742       };
17743     } catch (std::exception& e) {
17744       {
17745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17746       };
17747     } catch (Dali::DaliException e) {
17748       {
17749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17750       };
17751     } catch (...) {
17752       {
17753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17754       };
17755     }
17756   }
17757
17758   jresult = result;
17759   return jresult;
17760 }
17761
17762
17763 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17764   unsigned int jresult ;
17765   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17766   Dali::Matrix *arg2 = 0 ;
17767   bool result;
17768
17769   arg1 = (Dali::Property::Value *)jarg1;
17770   arg2 = (Dali::Matrix *)jarg2;
17771   if (!arg2) {
17772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17773     return 0;
17774   }
17775   {
17776     try {
17777       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17778     } catch (std::out_of_range& e) {
17779       {
17780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17781       };
17782     } catch (std::exception& e) {
17783       {
17784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17785       };
17786     } catch (Dali::DaliException e) {
17787       {
17788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17789       };
17790     } catch (...) {
17791       {
17792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17793       };
17794     }
17795   }
17796
17797   jresult = result;
17798   return jresult;
17799 }
17800
17801
17802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17803   unsigned int jresult ;
17804   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17805   Dali::AngleAxis *arg2 = 0 ;
17806   bool result;
17807
17808   arg1 = (Dali::Property::Value *)jarg1;
17809   arg2 = (Dali::AngleAxis *)jarg2;
17810   if (!arg2) {
17811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17812     return 0;
17813   }
17814   {
17815     try {
17816       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17817     } catch (std::out_of_range& e) {
17818       {
17819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17820       };
17821     } catch (std::exception& e) {
17822       {
17823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17824       };
17825     } catch (Dali::DaliException e) {
17826       {
17827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17828       };
17829     } catch (...) {
17830       {
17831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17832       };
17833     }
17834   }
17835
17836   jresult = result;
17837   return jresult;
17838 }
17839
17840
17841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17842   unsigned int jresult ;
17843   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17844   Dali::Quaternion *arg2 = 0 ;
17845   bool result;
17846
17847   arg1 = (Dali::Property::Value *)jarg1;
17848   arg2 = (Dali::Quaternion *)jarg2;
17849   if (!arg2) {
17850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17851     return 0;
17852   }
17853   {
17854     try {
17855       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17856     } catch (std::out_of_range& e) {
17857       {
17858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17859       };
17860     } catch (std::exception& e) {
17861       {
17862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17863       };
17864     } catch (Dali::DaliException e) {
17865       {
17866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17867       };
17868     } catch (...) {
17869       {
17870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17871       };
17872     }
17873   }
17874
17875   jresult = result;
17876   return jresult;
17877 }
17878
17879
17880 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17881   unsigned int jresult ;
17882   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17883   std::string *arg2 = 0 ;
17884   bool result;
17885
17886   arg1 = (Dali::Property::Value *)jarg1;
17887
17888   //typemap in
17889   std::string temp;
17890   arg2 = &temp;
17891
17892   {
17893     try {
17894       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17895     } catch (std::out_of_range& e) {
17896       {
17897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17898       };
17899     } catch (std::exception& e) {
17900       {
17901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17902       };
17903     } catch (Dali::DaliException e) {
17904       {
17905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17906       };
17907     } catch (...) {
17908       {
17909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17910       };
17911     }
17912   }
17913
17914   jresult = result;
17915
17916   //Typemap argout in c++ file.
17917   //This will convert c++ string to c# string
17918   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17919
17920   return jresult;
17921 }
17922
17923
17924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17925   unsigned int jresult ;
17926   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17927   Dali::Property::Array *arg2 = 0 ;
17928   bool result;
17929
17930   arg1 = (Dali::Property::Value *)jarg1;
17931   arg2 = (Dali::Property::Array *)jarg2;
17932   if (!arg2) {
17933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17934     return 0;
17935   }
17936   {
17937     try {
17938       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17939     } catch (std::out_of_range& e) {
17940       {
17941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17942       };
17943     } catch (std::exception& e) {
17944       {
17945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17946       };
17947     } catch (Dali::DaliException e) {
17948       {
17949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17950       };
17951     } catch (...) {
17952       {
17953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17954       };
17955     }
17956   }
17957
17958   jresult = result;
17959   return jresult;
17960 }
17961
17962
17963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17964   unsigned int jresult ;
17965   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17966   Dali::Property::Map *arg2 = 0 ;
17967   bool result;
17968
17969   arg1 = (Dali::Property::Value *)jarg1;
17970   arg2 = (Dali::Property::Map *)jarg2;
17971   if (!arg2) {
17972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17973     return 0;
17974   }
17975   {
17976     try {
17977       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17978     } catch (std::out_of_range& e) {
17979       {
17980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17981       };
17982     } catch (std::exception& e) {
17983       {
17984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17985       };
17986     } catch (Dali::DaliException e) {
17987       {
17988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17989       };
17990     } catch (...) {
17991       {
17992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17993       };
17994     }
17995   }
17996
17997   jresult = result;
17998   return jresult;
17999 }
18000
18001
18002 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
18003   unsigned int jresult ;
18004   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18005   Extents *arg2 = 0 ;
18006   bool result;
18007
18008   arg1 = (Dali::Property::Value *)jarg1;
18009   arg2 = (Extents *)jarg2;
18010   if (!arg2) {
18011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
18012     return 0;
18013   }
18014   {
18015     try {
18016       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
18017     } catch (std::out_of_range& e) {
18018       {
18019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18020       };
18021     } catch (std::exception& e) {
18022       {
18023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18024       };
18025     } catch (...) {
18026       {
18027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18028       };
18029     }
18030   }
18031   jresult = result;
18032   return jresult;
18033 }
18034
18035
18036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
18037   void * jresult ;
18038   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18039   Dali::Property::Array *result = 0 ;
18040
18041   arg1 = (Dali::Property::Value *)jarg1;
18042   {
18043     try {
18044       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
18045     } catch (std::out_of_range& e) {
18046       {
18047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18048       };
18049     } catch (std::exception& e) {
18050       {
18051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18052       };
18053     } catch (Dali::DaliException e) {
18054       {
18055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18056       };
18057     } catch (...) {
18058       {
18059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18060       };
18061     }
18062   }
18063
18064   jresult = (void *)result;
18065   return jresult;
18066 }
18067
18068
18069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
18070   void * jresult ;
18071   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18072   Dali::Property::Map *result = 0 ;
18073
18074   arg1 = (Dali::Property::Value *)jarg1;
18075   {
18076     try {
18077       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18078     } catch (std::out_of_range& e) {
18079       {
18080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18081       };
18082     } catch (std::exception& e) {
18083       {
18084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18085       };
18086     } catch (Dali::DaliException e) {
18087       {
18088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18089       };
18090     } catch (...) {
18091       {
18092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18093       };
18094     }
18095   }
18096
18097   jresult = (void *)result;
18098   return jresult;
18099 }
18100
18101
18102 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18103   char * jresult ;
18104   Dali::Property::Type arg1 ;
18105   char *result = 0 ;
18106
18107   arg1 = (Dali::Property::Type)jarg1;
18108   {
18109     try {
18110       result = (char *)Dali::PropertyTypes::GetName(arg1);
18111     } catch (std::out_of_range& e) {
18112       {
18113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18114       };
18115     } catch (std::exception& e) {
18116       {
18117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18118       };
18119     } catch (Dali::DaliException e) {
18120       {
18121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18122       };
18123     } catch (...) {
18124       {
18125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18126       };
18127     }
18128   }
18129
18130   jresult = SWIG_csharp_string_callback((const char *)result);
18131   return jresult;
18132 }
18133
18134
18135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18136   unsigned int jresult ;
18137   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18138   std::string *arg2 = 0 ;
18139   Dali::Property::Map *arg3 = 0 ;
18140   bool result;
18141
18142   arg1 = (Dali::BaseObject *)jarg1;
18143   if (!jarg2) {
18144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18145     return 0;
18146   }
18147   std::string arg2_str(jarg2);
18148   arg2 = &arg2_str;
18149   arg3 = (Dali::Property::Map *)jarg3;
18150   if (!arg3) {
18151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18152     return 0;
18153   }
18154   {
18155     try {
18156       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18157     } catch (std::out_of_range& e) {
18158       {
18159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18160       };
18161     } catch (std::exception& e) {
18162       {
18163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18164       };
18165     } catch (Dali::DaliException e) {
18166       {
18167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18168       };
18169     } catch (...) {
18170       {
18171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18172       };
18173     }
18174   }
18175
18176   jresult = result;
18177
18178   //argout typemap for const std::string&
18179
18180   return jresult;
18181 }
18182
18183
18184 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18185   char * jresult ;
18186   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18187   std::string *result = 0 ;
18188
18189   arg1 = (Dali::BaseObject *)jarg1;
18190   {
18191     try {
18192       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18193     } catch (std::out_of_range& e) {
18194       {
18195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18196       };
18197     } catch (std::exception& e) {
18198       {
18199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18200       };
18201     } catch (Dali::DaliException e) {
18202       {
18203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18204       };
18205     } catch (...) {
18206       {
18207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18208       };
18209     }
18210   }
18211
18212   jresult = SWIG_csharp_string_callback(result->c_str());
18213   return jresult;
18214 }
18215
18216
18217 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18218   unsigned int jresult ;
18219   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18220   Dali::TypeInfo *arg2 = 0 ;
18221   bool result;
18222
18223   arg1 = (Dali::BaseObject *)jarg1;
18224   arg2 = (Dali::TypeInfo *)jarg2;
18225   if (!arg2) {
18226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18227     return 0;
18228   }
18229   {
18230     try {
18231       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18232     } catch (std::out_of_range& e) {
18233       {
18234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18235       };
18236     } catch (std::exception& e) {
18237       {
18238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18239       };
18240     } catch (Dali::DaliException e) {
18241       {
18242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18243       };
18244     } catch (...) {
18245       {
18246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18247       };
18248     }
18249   }
18250
18251   jresult = result;
18252   return jresult;
18253 }
18254
18255
18256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18257   unsigned int jresult ;
18258   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18259   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18260   std::string *arg3 = 0 ;
18261   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18262   bool result;
18263
18264   arg1 = (Dali::BaseObject *)jarg1;
18265   arg2 = (ConnectionTrackerInterface *)jarg2;
18266   if (!jarg3) {
18267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18268     return 0;
18269   }
18270   std::string arg3_str(jarg3);
18271   arg3 = &arg3_str;
18272   arg4 = (FunctorDelegate *)jarg4;
18273   {
18274     try {
18275       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18276     } catch (std::out_of_range& e) {
18277       {
18278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18279       };
18280     } catch (std::exception& e) {
18281       {
18282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18283       };
18284     } catch (Dali::DaliException e) {
18285       {
18286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18287       };
18288     } catch (...) {
18289       {
18290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18291       };
18292     }
18293   }
18294
18295   jresult = result;
18296
18297   //argout typemap for const std::string&
18298
18299   return jresult;
18300 }
18301
18302
18303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18304   void * jresult ;
18305   Dali::BaseHandle *arg1 = 0 ;
18306   Dali::BaseObject *result = 0 ;
18307
18308   arg1 = (Dali::BaseHandle *)jarg1;
18309   if (!arg1) {
18310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18311     return 0;
18312   }
18313   {
18314     try {
18315       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18316     } catch (std::out_of_range& e) {
18317       {
18318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18319       };
18320     } catch (std::exception& e) {
18321       {
18322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18323       };
18324     } catch (Dali::DaliException e) {
18325       {
18326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18327       };
18328     } catch (...) {
18329       {
18330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18331       };
18332     }
18333   }
18334
18335   jresult = (void *)result;
18336   return jresult;
18337 }
18338
18339
18340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18341   void * jresult ;
18342   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18343   Dali::BaseHandle *result = 0 ;
18344
18345   arg1 = (Dali::BaseObject *)jarg1;
18346   {
18347     try {
18348       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18349     } catch (std::out_of_range& e) {
18350       {
18351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18352       };
18353     } catch (std::exception& e) {
18354       {
18355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18356       };
18357     } catch (Dali::DaliException e) {
18358       {
18359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18360       };
18361     } catch (...) {
18362       {
18363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18364       };
18365     }
18366   }
18367
18368   jresult = (void *)result;
18369   return jresult;
18370 }
18371
18372
18373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18374   void * jresult ;
18375   Dali::BaseHandle *result = 0 ;
18376
18377   {
18378     try {
18379       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18380     } catch (std::out_of_range& e) {
18381       {
18382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18383       };
18384     } catch (std::exception& e) {
18385       {
18386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18387       };
18388     } catch (Dali::DaliException e) {
18389       {
18390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18391       };
18392     } catch (...) {
18393       {
18394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18395       };
18396     }
18397   }
18398
18399   jresult = (void *)result;
18400   return jresult;
18401 }
18402
18403
18404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18405   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18406
18407   arg1 = (Dali::BaseHandle *)jarg1;
18408   {
18409     try {
18410       delete arg1;
18411     } catch (std::out_of_range& e) {
18412       {
18413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18414       };
18415     } catch (std::exception& e) {
18416       {
18417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18418       };
18419     } catch (Dali::DaliException e) {
18420       {
18421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18422       };
18423     } catch (...) {
18424       {
18425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18426       };
18427     }
18428   }
18429
18430 }
18431
18432
18433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18434   void * jresult ;
18435   Dali::BaseHandle *arg1 = 0 ;
18436   Dali::BaseHandle *result = 0 ;
18437
18438   arg1 = (Dali::BaseHandle *)jarg1;
18439   if (!arg1) {
18440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18441     return 0;
18442   }
18443   {
18444     try {
18445       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18446     } catch (std::out_of_range& e) {
18447       {
18448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18449       };
18450     } catch (std::exception& e) {
18451       {
18452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18453       };
18454     } catch (Dali::DaliException e) {
18455       {
18456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18457       };
18458     } catch (...) {
18459       {
18460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18461       };
18462     }
18463   }
18464
18465   jresult = (void *)result;
18466   return jresult;
18467 }
18468
18469
18470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18471   void * jresult ;
18472   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18473   Dali::BaseHandle *arg2 = 0 ;
18474   Dali::BaseHandle *result = 0 ;
18475
18476   arg1 = (Dali::BaseHandle *)jarg1;
18477   arg2 = (Dali::BaseHandle *)jarg2;
18478   if (!arg2) {
18479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18480     return 0;
18481   }
18482   {
18483     try {
18484       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18485     } catch (std::out_of_range& e) {
18486       {
18487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18488       };
18489     } catch (std::exception& e) {
18490       {
18491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18492       };
18493     } catch (Dali::DaliException e) {
18494       {
18495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18496       };
18497     } catch (...) {
18498       {
18499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18500       };
18501     }
18502   }
18503
18504   jresult = (void *)result;
18505   return jresult;
18506 }
18507
18508
18509 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18510   unsigned int jresult ;
18511   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18512   std::string *arg2 = 0 ;
18513   Dali::Property::Map *arg3 = 0 ;
18514   bool result;
18515
18516   arg1 = (Dali::BaseHandle *)jarg1;
18517   if (!jarg2) {
18518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18519     return 0;
18520   }
18521   std::string arg2_str(jarg2);
18522   arg2 = &arg2_str;
18523   arg3 = (Dali::Property::Map *)jarg3;
18524   if (!arg3) {
18525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18526     return 0;
18527   }
18528   {
18529     try {
18530       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18531     } catch (std::out_of_range& e) {
18532       {
18533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18534       };
18535     } catch (std::exception& e) {
18536       {
18537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18538       };
18539     } catch (Dali::DaliException e) {
18540       {
18541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18542       };
18543     } catch (...) {
18544       {
18545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18546       };
18547     }
18548   }
18549
18550   jresult = result;
18551
18552   //argout typemap for const std::string&
18553
18554   return jresult;
18555 }
18556
18557
18558 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18559   char * jresult ;
18560   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18561   std::string *result = 0 ;
18562
18563   arg1 = (Dali::BaseHandle *)jarg1;
18564   {
18565     try {
18566       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
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 = SWIG_csharp_string_callback(result->c_str());
18587   return jresult;
18588 }
18589
18590
18591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18592   unsigned int jresult ;
18593   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18594   Dali::TypeInfo *arg2 = 0 ;
18595   bool result;
18596
18597   arg1 = (Dali::BaseHandle *)jarg1;
18598   arg2 = (Dali::TypeInfo *)jarg2;
18599   if (!arg2) {
18600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18601     return 0;
18602   }
18603   {
18604     try {
18605       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18606     } catch (std::out_of_range& e) {
18607       {
18608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18609       };
18610     } catch (std::exception& e) {
18611       {
18612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18613       };
18614     } catch (Dali::DaliException e) {
18615       {
18616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18617       };
18618     } catch (...) {
18619       {
18620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18621       };
18622     }
18623   }
18624
18625   jresult = result;
18626   return jresult;
18627 }
18628
18629
18630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18631   void * jresult ;
18632   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18633   Dali::BaseObject *result = 0 ;
18634
18635   arg1 = (Dali::BaseHandle *)jarg1;
18636   {
18637     try {
18638       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18639     } catch (std::out_of_range& e) {
18640       {
18641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18642       };
18643     } catch (std::exception& e) {
18644       {
18645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18646       };
18647     } catch (Dali::DaliException e) {
18648       {
18649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18650       };
18651     } catch (...) {
18652       {
18653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18654       };
18655     }
18656   }
18657
18658   jresult = (void *)result;
18659   return jresult;
18660 }
18661
18662
18663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18664   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18665
18666   arg1 = (Dali::BaseHandle *)jarg1;
18667   {
18668     try {
18669       (arg1)->Reset();
18670     } catch (std::out_of_range& e) {
18671       {
18672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18673       };
18674     } catch (std::exception& e) {
18675       {
18676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18677       };
18678     } catch (Dali::DaliException e) {
18679       {
18680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18681       };
18682     } catch (...) {
18683       {
18684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18685       };
18686     }
18687   }
18688
18689 }
18690
18691
18692 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18693   unsigned int jresult ;
18694   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18695   Dali::BaseHandle *arg2 = 0 ;
18696   bool result;
18697
18698   arg1 = (Dali::BaseHandle *)jarg1;
18699   arg2 = (Dali::BaseHandle *)jarg2;
18700   if (!arg2) {
18701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18702     return 0;
18703   }
18704   {
18705     try {
18706       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
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 = result;
18727   return jresult;
18728 }
18729
18730
18731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18732   unsigned int jresult ;
18733   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18734   Dali::BaseHandle *arg2 = 0 ;
18735   bool result;
18736
18737   arg1 = (Dali::BaseHandle *)jarg1;
18738   arg2 = (Dali::BaseHandle *)jarg2;
18739   if (!arg2) {
18740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18741     return 0;
18742   }
18743   {
18744     try {
18745       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18746     } catch (std::out_of_range& e) {
18747       {
18748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18749       };
18750     } catch (std::exception& e) {
18751       {
18752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18753       };
18754     } catch (Dali::DaliException e) {
18755       {
18756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18757       };
18758     } catch (...) {
18759       {
18760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18761       };
18762     }
18763   }
18764
18765   jresult = result;
18766   return jresult;
18767 }
18768
18769
18770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18771   void * jresult ;
18772   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18773   Dali::RefObject *result = 0 ;
18774
18775   arg1 = (Dali::BaseHandle *)jarg1;
18776   {
18777     try {
18778       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
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 = (void *)result;
18799   return jresult;
18800 }
18801
18802
18803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18804   unsigned int jresult ;
18805   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18806   bool result;
18807
18808   arg1 = (Dali::BaseHandle *)jarg1;
18809   {
18810     try {
18811       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18812     } catch (std::out_of_range& e) {
18813       {
18814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18815       };
18816     } catch (std::exception& e) {
18817       {
18818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18819       };
18820     } catch (Dali::DaliException e) {
18821       {
18822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18823       };
18824     } catch (...) {
18825       {
18826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18827       };
18828     }
18829   }
18830
18831   jresult = result;
18832   return jresult;
18833 }
18834
18835
18836 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18837   unsigned int jresult ;
18838   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18839   Dali::BaseHandle *arg2 = 0 ;
18840   bool result;
18841
18842   arg1 = (Dali::BaseHandle *)jarg1;
18843   arg2 = (Dali::BaseHandle *)jarg2;
18844   if (!arg2) {
18845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18846     return 0;
18847   }
18848   {
18849     try {
18850       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18851     } catch (std::out_of_range& e) {
18852       {
18853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18854       };
18855     } catch (std::exception& e) {
18856       {
18857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18858       };
18859     } catch (Dali::DaliException e) {
18860       {
18861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18862       };
18863     } catch (...) {
18864       {
18865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18866       };
18867     }
18868   }
18869
18870   jresult = result;
18871   return jresult;
18872 }
18873
18874
18875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18876   unsigned int jresult ;
18877   Dali::BaseHandle *arg1 = 0 ;
18878   Dali::BaseHandle *arg2 = 0 ;
18879   bool result;
18880
18881   arg1 = (Dali::BaseHandle *)jarg1;
18882   if (!arg1) {
18883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18884     return 0;
18885   }
18886   arg2 = (Dali::BaseHandle *)jarg2;
18887   if (!arg2) {
18888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18889     return 0;
18890   }
18891   {
18892     try {
18893       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18894     } catch (std::out_of_range& e) {
18895       {
18896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18897       };
18898     } catch (std::exception& e) {
18899       {
18900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18901       };
18902     } catch (Dali::DaliException e) {
18903       {
18904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18905       };
18906     } catch (...) {
18907       {
18908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18909       };
18910     }
18911   }
18912
18913   jresult = result;
18914   return jresult;
18915 }
18916
18917
18918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18919   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18920
18921   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18922   {
18923     try {
18924       delete arg1;
18925     } catch (std::out_of_range& e) {
18926       {
18927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18928       };
18929     } catch (std::exception& e) {
18930       {
18931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18932       };
18933     } catch (Dali::DaliException e) {
18934       {
18935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18936       };
18937     } catch (...) {
18938       {
18939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18940       };
18941     }
18942   }
18943
18944 }
18945
18946
18947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18948   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18949   SlotObserver *arg2 = (SlotObserver *) 0 ;
18950   CallbackBase *arg3 = (CallbackBase *) 0 ;
18951
18952   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18953   arg2 = (SlotObserver *)jarg2;
18954   arg3 = (CallbackBase *)jarg3;
18955   {
18956     try {
18957       (arg1)->SignalConnected(arg2,arg3);
18958     } catch (std::out_of_range& e) {
18959       {
18960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18961       };
18962     } catch (std::exception& e) {
18963       {
18964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18965       };
18966     } catch (Dali::DaliException e) {
18967       {
18968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18969       };
18970     } catch (...) {
18971       {
18972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18973       };
18974     }
18975   }
18976
18977 }
18978
18979
18980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18981   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18982
18983   arg1 = (Dali::SignalObserver *)jarg1;
18984   {
18985     try {
18986       delete arg1;
18987     } catch (std::out_of_range& e) {
18988       {
18989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18990       };
18991     } catch (std::exception& e) {
18992       {
18993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18994       };
18995     } catch (Dali::DaliException e) {
18996       {
18997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18998       };
18999     } catch (...) {
19000       {
19001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19002       };
19003     }
19004   }
19005
19006 }
19007
19008
19009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19010   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
19011   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19012   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19013
19014   arg1 = (Dali::SignalObserver *)jarg1;
19015   arg2 = (Dali::SlotObserver *)jarg2;
19016   arg3 = (Dali::CallbackBase *)jarg3;
19017   {
19018     try {
19019       (arg1)->SignalDisconnected(arg2,arg3);
19020     } catch (std::out_of_range& e) {
19021       {
19022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19023       };
19024     } catch (std::exception& e) {
19025       {
19026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19027       };
19028     } catch (Dali::DaliException e) {
19029       {
19030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19031       };
19032     } catch (...) {
19033       {
19034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19035       };
19036     }
19037   }
19038
19039 }
19040
19041
19042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
19043   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19044
19045   arg1 = (Dali::SlotObserver *)jarg1;
19046   {
19047     try {
19048       delete arg1;
19049     } catch (std::out_of_range& e) {
19050       {
19051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19052       };
19053     } catch (std::exception& e) {
19054       {
19055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19056       };
19057     } catch (Dali::DaliException e) {
19058       {
19059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19060       };
19061     } catch (...) {
19062       {
19063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19064       };
19065     }
19066   }
19067
19068 }
19069
19070
19071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
19072   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19073   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19074
19075   arg1 = (Dali::SlotObserver *)jarg1;
19076   arg2 = (Dali::CallbackBase *)jarg2;
19077   {
19078     try {
19079       (arg1)->SlotDisconnected(arg2);
19080     } catch (std::out_of_range& e) {
19081       {
19082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19083       };
19084     } catch (std::exception& e) {
19085       {
19086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19087       };
19088     } catch (Dali::DaliException e) {
19089       {
19090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19091       };
19092     } catch (...) {
19093       {
19094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19095       };
19096     }
19097   }
19098
19099 }
19100
19101
19102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19103   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19104
19105   arg1 = (Dali::ConnectionTracker *)jarg1;
19106   {
19107     try {
19108       delete arg1;
19109     } catch (std::out_of_range& e) {
19110       {
19111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19112       };
19113     } catch (std::exception& e) {
19114       {
19115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19116       };
19117     } catch (Dali::DaliException e) {
19118       {
19119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19120       };
19121     } catch (...) {
19122       {
19123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19124       };
19125     }
19126   }
19127
19128 }
19129
19130
19131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19132   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19133
19134   arg1 = (Dali::ConnectionTracker *)jarg1;
19135   {
19136     try {
19137       (arg1)->DisconnectAll();
19138     } catch (std::out_of_range& e) {
19139       {
19140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19141       };
19142     } catch (std::exception& e) {
19143       {
19144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19145       };
19146     } catch (Dali::DaliException e) {
19147       {
19148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19149       };
19150     } catch (...) {
19151       {
19152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19153       };
19154     }
19155   }
19156
19157 }
19158
19159
19160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19161   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19162   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19163   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19164
19165   arg1 = (Dali::ConnectionTracker *)jarg1;
19166   arg2 = (Dali::SlotObserver *)jarg2;
19167   arg3 = (Dali::CallbackBase *)jarg3;
19168   {
19169     try {
19170       (arg1)->SignalConnected(arg2,arg3);
19171     } catch (std::out_of_range& e) {
19172       {
19173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19174       };
19175     } catch (std::exception& e) {
19176       {
19177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19178       };
19179     } catch (Dali::DaliException e) {
19180       {
19181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19182       };
19183     } catch (...) {
19184       {
19185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19186       };
19187     }
19188   }
19189
19190 }
19191
19192
19193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19194   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19195   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19196   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19197
19198   arg1 = (Dali::ConnectionTracker *)jarg1;
19199   arg2 = (Dali::SlotObserver *)jarg2;
19200   arg3 = (Dali::CallbackBase *)jarg3;
19201   {
19202     try {
19203       (arg1)->SignalDisconnected(arg2,arg3);
19204     } catch (std::out_of_range& e) {
19205       {
19206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19207       };
19208     } catch (std::exception& e) {
19209       {
19210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19211       };
19212     } catch (Dali::DaliException e) {
19213       {
19214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19215       };
19216     } catch (...) {
19217       {
19218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19219       };
19220     }
19221   }
19222
19223 }
19224
19225
19226 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19227   unsigned long jresult ;
19228   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19229   std::size_t result;
19230
19231   arg1 = (Dali::ConnectionTracker *)jarg1;
19232   {
19233     try {
19234       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19235     } catch (std::out_of_range& e) {
19236       {
19237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19238       };
19239     } catch (std::exception& e) {
19240       {
19241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19242       };
19243     } catch (Dali::DaliException e) {
19244       {
19245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19246       };
19247     } catch (...) {
19248       {
19249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19250       };
19251     }
19252   }
19253
19254   jresult = (unsigned long)result;
19255   return jresult;
19256 }
19257
19258
19259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19260   void * jresult ;
19261   Dali::ObjectRegistry *result = 0 ;
19262
19263   {
19264     try {
19265       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19266     } catch (std::out_of_range& e) {
19267       {
19268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19269       };
19270     } catch (std::exception& e) {
19271       {
19272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19273       };
19274     } catch (Dali::DaliException e) {
19275       {
19276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19277       };
19278     } catch (...) {
19279       {
19280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19281       };
19282     }
19283   }
19284
19285   jresult = (void *)result;
19286   return jresult;
19287 }
19288
19289
19290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19291   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19292
19293   arg1 = (Dali::ObjectRegistry *)jarg1;
19294   {
19295     try {
19296       delete arg1;
19297     } catch (std::out_of_range& e) {
19298       {
19299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19300       };
19301     } catch (std::exception& e) {
19302       {
19303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19304       };
19305     } catch (Dali::DaliException e) {
19306       {
19307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19308       };
19309     } catch (...) {
19310       {
19311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19312       };
19313     }
19314   }
19315
19316 }
19317
19318
19319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19320   void * jresult ;
19321   Dali::ObjectRegistry *arg1 = 0 ;
19322   Dali::ObjectRegistry *result = 0 ;
19323
19324   arg1 = (Dali::ObjectRegistry *)jarg1;
19325   if (!arg1) {
19326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19327     return 0;
19328   }
19329   {
19330     try {
19331       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
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_Assign(void * jarg1, void * jarg2) {
19357   void * jresult ;
19358   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19359   Dali::ObjectRegistry *arg2 = 0 ;
19360   Dali::ObjectRegistry *result = 0 ;
19361
19362   arg1 = (Dali::ObjectRegistry *)jarg1;
19363   arg2 = (Dali::ObjectRegistry *)jarg2;
19364   if (!arg2) {
19365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19366     return 0;
19367   }
19368   {
19369     try {
19370       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19371     } catch (std::out_of_range& e) {
19372       {
19373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19374       };
19375     } catch (std::exception& e) {
19376       {
19377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19378       };
19379     } catch (Dali::DaliException e) {
19380       {
19381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19382       };
19383     } catch (...) {
19384       {
19385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19386       };
19387     }
19388   }
19389
19390   jresult = (void *)result;
19391   return jresult;
19392 }
19393
19394
19395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19396   void * jresult ;
19397   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19398   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19399
19400   arg1 = (Dali::ObjectRegistry *)jarg1;
19401   {
19402     try {
19403       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19404     } catch (std::out_of_range& e) {
19405       {
19406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19407       };
19408     } catch (std::exception& e) {
19409       {
19410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19411       };
19412     } catch (Dali::DaliException e) {
19413       {
19414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19415       };
19416     } catch (...) {
19417       {
19418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19419       };
19420     }
19421   }
19422
19423   jresult = (void *)result;
19424   return jresult;
19425 }
19426
19427
19428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19429   void * jresult ;
19430   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19431   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19432
19433   arg1 = (Dali::ObjectRegistry *)jarg1;
19434   {
19435     try {
19436       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19437     } catch (std::out_of_range& e) {
19438       {
19439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19440       };
19441     } catch (std::exception& e) {
19442       {
19443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19444       };
19445     } catch (Dali::DaliException e) {
19446       {
19447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19448       };
19449     } catch (...) {
19450       {
19451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19452       };
19453     }
19454   }
19455
19456   jresult = (void *)result;
19457   return jresult;
19458 }
19459
19460
19461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19462   void * jresult ;
19463   Dali::PropertyCondition *result = 0 ;
19464
19465   {
19466     try {
19467       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19468     } catch (std::out_of_range& e) {
19469       {
19470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19471       };
19472     } catch (std::exception& e) {
19473       {
19474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19475       };
19476     } catch (Dali::DaliException e) {
19477       {
19478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19479       };
19480     } catch (...) {
19481       {
19482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19483       };
19484     }
19485   }
19486
19487   jresult = (void *)result;
19488   return jresult;
19489 }
19490
19491
19492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19493   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19494
19495   arg1 = (Dali::PropertyCondition *)jarg1;
19496   {
19497     try {
19498       delete arg1;
19499     } catch (std::out_of_range& e) {
19500       {
19501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19502       };
19503     } catch (std::exception& e) {
19504       {
19505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19506       };
19507     } catch (Dali::DaliException e) {
19508       {
19509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19510       };
19511     } catch (...) {
19512       {
19513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19514       };
19515     }
19516   }
19517
19518 }
19519
19520
19521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19522   void * jresult ;
19523   Dali::PropertyCondition *arg1 = 0 ;
19524   Dali::PropertyCondition *result = 0 ;
19525
19526   arg1 = (Dali::PropertyCondition *)jarg1;
19527   if (!arg1) {
19528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19529     return 0;
19530   }
19531   {
19532     try {
19533       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
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 (Dali::DaliException e) {
19543       {
19544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19545       };
19546     } catch (...) {
19547       {
19548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19549       };
19550     }
19551   }
19552
19553   jresult = (void *)result;
19554   return jresult;
19555 }
19556
19557
19558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19559   void * jresult ;
19560   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19561   Dali::PropertyCondition *arg2 = 0 ;
19562   Dali::PropertyCondition *result = 0 ;
19563
19564   arg1 = (Dali::PropertyCondition *)jarg1;
19565   arg2 = (Dali::PropertyCondition *)jarg2;
19566   if (!arg2) {
19567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19568     return 0;
19569   }
19570   {
19571     try {
19572       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19573     } catch (std::out_of_range& e) {
19574       {
19575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19576       };
19577     } catch (std::exception& e) {
19578       {
19579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19580       };
19581     } catch (Dali::DaliException e) {
19582       {
19583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19584       };
19585     } catch (...) {
19586       {
19587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19588       };
19589     }
19590   }
19591
19592   jresult = (void *)result;
19593   return jresult;
19594 }
19595
19596
19597 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19598   unsigned long jresult ;
19599   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19600   std::size_t result;
19601
19602   arg1 = (Dali::PropertyCondition *)jarg1;
19603   {
19604     try {
19605       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19606     } catch (std::out_of_range& e) {
19607       {
19608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19609       };
19610     } catch (std::exception& e) {
19611       {
19612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19613       };
19614     } catch (...) {
19615       {
19616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19617       };
19618     }
19619   }
19620   jresult = (unsigned long)result;
19621   return jresult;
19622 }
19623
19624
19625 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19626   float jresult ;
19627   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19628   std::size_t arg2 ;
19629   float result;
19630
19631   arg1 = (Dali::PropertyCondition *)jarg1;
19632   arg2 = (std::size_t)jarg2;
19633   {
19634     try {
19635       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19636     } catch (std::out_of_range& e) {
19637       {
19638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19639       };
19640     } catch (std::exception& e) {
19641       {
19642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19643       };
19644     } catch (...) {
19645       {
19646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19647       };
19648     }
19649   }
19650   jresult = result;
19651   return jresult;
19652 }
19653
19654
19655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19656   void * jresult ;
19657   float arg1 ;
19658   Dali::PropertyCondition result;
19659
19660   arg1 = (float)jarg1;
19661   {
19662     try {
19663       result = Dali::LessThanCondition(arg1);
19664     } catch (std::out_of_range& e) {
19665       {
19666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19667       };
19668     } catch (std::exception& e) {
19669       {
19670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19671       };
19672     } catch (Dali::DaliException e) {
19673       {
19674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19675       };
19676     } catch (...) {
19677       {
19678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19679       };
19680     }
19681   }
19682
19683   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19684   return jresult;
19685 }
19686
19687
19688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19689   void * jresult ;
19690   float arg1 ;
19691   Dali::PropertyCondition result;
19692
19693   arg1 = (float)jarg1;
19694   {
19695     try {
19696       result = Dali::GreaterThanCondition(arg1);
19697     } catch (std::out_of_range& e) {
19698       {
19699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19700       };
19701     } catch (std::exception& e) {
19702       {
19703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19704       };
19705     } catch (Dali::DaliException e) {
19706       {
19707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19708       };
19709     } catch (...) {
19710       {
19711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19712       };
19713     }
19714   }
19715
19716   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19717   return jresult;
19718 }
19719
19720
19721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19722   void * jresult ;
19723   float arg1 ;
19724   float arg2 ;
19725   Dali::PropertyCondition result;
19726
19727   arg1 = (float)jarg1;
19728   arg2 = (float)jarg2;
19729   {
19730     try {
19731       result = Dali::InsideCondition(arg1,arg2);
19732     } catch (std::out_of_range& e) {
19733       {
19734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19735       };
19736     } catch (std::exception& e) {
19737       {
19738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19739       };
19740     } catch (Dali::DaliException e) {
19741       {
19742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19743       };
19744     } catch (...) {
19745       {
19746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19747       };
19748     }
19749   }
19750
19751   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19752   return jresult;
19753 }
19754
19755
19756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19757   void * jresult ;
19758   float arg1 ;
19759   float arg2 ;
19760   Dali::PropertyCondition result;
19761
19762   arg1 = (float)jarg1;
19763   arg2 = (float)jarg2;
19764   {
19765     try {
19766       result = Dali::OutsideCondition(arg1,arg2);
19767     } catch (std::out_of_range& e) {
19768       {
19769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19770       };
19771     } catch (std::exception& e) {
19772       {
19773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19774       };
19775     } catch (Dali::DaliException e) {
19776       {
19777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19778       };
19779     } catch (...) {
19780       {
19781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19782       };
19783     }
19784   }
19785
19786   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19787   return jresult;
19788 }
19789
19790
19791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19792   void * jresult ;
19793   float arg1 ;
19794   float arg2 ;
19795   Dali::PropertyCondition result;
19796
19797   arg1 = (float)jarg1;
19798   arg2 = (float)jarg2;
19799   {
19800     try {
19801       result = Dali::StepCondition(arg1,arg2);
19802     } catch (std::out_of_range& e) {
19803       {
19804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19805       };
19806     } catch (std::exception& e) {
19807       {
19808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19809       };
19810     } catch (Dali::DaliException e) {
19811       {
19812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19813       };
19814     } catch (...) {
19815       {
19816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19817       };
19818     }
19819   }
19820
19821   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19822   return jresult;
19823 }
19824
19825
19826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19827   void * jresult ;
19828   float arg1 ;
19829   Dali::PropertyCondition result;
19830
19831   arg1 = (float)jarg1;
19832   {
19833     try {
19834       result = Dali::StepCondition(arg1);
19835     } catch (std::out_of_range& e) {
19836       {
19837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19838       };
19839     } catch (std::exception& e) {
19840       {
19841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19842       };
19843     } catch (Dali::DaliException e) {
19844       {
19845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19846       };
19847     } catch (...) {
19848       {
19849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19850       };
19851     }
19852   }
19853
19854   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19855   return jresult;
19856 }
19857
19858
19859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19860   void * jresult ;
19861   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19862   Dali::PropertyCondition result;
19863
19864   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19865   if (!arg1) {
19866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19867     return 0;
19868   }
19869   {
19870     try {
19871       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19872     } catch (std::out_of_range& e) {
19873       {
19874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19875       };
19876     } catch (std::exception& e) {
19877       {
19878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19879       };
19880     } catch (Dali::DaliException e) {
19881       {
19882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19883       };
19884     } catch (...) {
19885       {
19886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19887       };
19888     }
19889   }
19890
19891   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19892   return jresult;
19893 }
19894
19895
19896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19897   void * jresult ;
19898   Dali::PropertyNotification *result = 0 ;
19899
19900   {
19901     try {
19902       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19903     } catch (std::out_of_range& e) {
19904       {
19905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19906       };
19907     } catch (std::exception& e) {
19908       {
19909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19910       };
19911     } catch (Dali::DaliException e) {
19912       {
19913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19914       };
19915     } catch (...) {
19916       {
19917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19918       };
19919     }
19920   }
19921
19922   jresult = (void *)result;
19923   return jresult;
19924 }
19925
19926
19927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19928   void * jresult ;
19929   Dali::BaseHandle arg1 ;
19930   Dali::BaseHandle *argp1 ;
19931   Dali::PropertyNotification result;
19932
19933   argp1 = (Dali::BaseHandle *)jarg1;
19934   if (!argp1) {
19935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19936     return 0;
19937   }
19938   arg1 = *argp1;
19939   {
19940     try {
19941       result = Dali::PropertyNotification::DownCast(arg1);
19942     } catch (std::out_of_range& e) {
19943       {
19944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19945       };
19946     } catch (std::exception& e) {
19947       {
19948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19949       };
19950     } catch (Dali::DaliException e) {
19951       {
19952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19953       };
19954     } catch (...) {
19955       {
19956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19957       };
19958     }
19959   }
19960
19961   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19962   return jresult;
19963 }
19964
19965
19966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19967   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19968
19969   arg1 = (Dali::PropertyNotification *)jarg1;
19970   {
19971     try {
19972       delete arg1;
19973     } catch (std::out_of_range& e) {
19974       {
19975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19976       };
19977     } catch (std::exception& e) {
19978       {
19979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19980       };
19981     } catch (Dali::DaliException e) {
19982       {
19983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19984       };
19985     } catch (...) {
19986       {
19987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19988       };
19989     }
19990   }
19991
19992 }
19993
19994
19995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19996   void * jresult ;
19997   Dali::PropertyNotification *arg1 = 0 ;
19998   Dali::PropertyNotification *result = 0 ;
19999
20000   arg1 = (Dali::PropertyNotification *)jarg1;
20001   if (!arg1) {
20002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
20003     return 0;
20004   }
20005   {
20006     try {
20007       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
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 = (void *)result;
20028   return jresult;
20029 }
20030
20031
20032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
20033   void * jresult ;
20034   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20035   Dali::PropertyNotification *arg2 = 0 ;
20036   Dali::PropertyNotification *result = 0 ;
20037
20038   arg1 = (Dali::PropertyNotification *)jarg1;
20039   arg2 = (Dali::PropertyNotification *)jarg2;
20040   if (!arg2) {
20041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
20042     return 0;
20043   }
20044   {
20045     try {
20046       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
20047     } catch (std::out_of_range& e) {
20048       {
20049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20050       };
20051     } catch (std::exception& e) {
20052       {
20053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20054       };
20055     } catch (Dali::DaliException e) {
20056       {
20057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20058       };
20059     } catch (...) {
20060       {
20061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20062       };
20063     }
20064   }
20065
20066   jresult = (void *)result;
20067   return jresult;
20068 }
20069
20070
20071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
20072   void * jresult ;
20073   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20074   Dali::PropertyCondition result;
20075
20076   arg1 = (Dali::PropertyNotification *)jarg1;
20077   {
20078     try {
20079       result = (arg1)->GetCondition();
20080     } catch (std::out_of_range& e) {
20081       {
20082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20083       };
20084     } catch (std::exception& e) {
20085       {
20086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20087       };
20088     } catch (Dali::DaliException e) {
20089       {
20090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20091       };
20092     } catch (...) {
20093       {
20094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20095       };
20096     }
20097   }
20098
20099   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20100   return jresult;
20101 }
20102
20103
20104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20105   void * jresult ;
20106   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20107   Dali::Handle result;
20108
20109   arg1 = (Dali::PropertyNotification *)jarg1;
20110   {
20111     try {
20112       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20113     } catch (std::out_of_range& e) {
20114       {
20115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20116       };
20117     } catch (std::exception& e) {
20118       {
20119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20120       };
20121     } catch (Dali::DaliException e) {
20122       {
20123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20124       };
20125     } catch (...) {
20126       {
20127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20128       };
20129     }
20130   }
20131
20132   jresult = new Dali::Handle((const Dali::Handle &)result);
20133   return jresult;
20134 }
20135
20136
20137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20138   int jresult ;
20139   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20140   Dali::Property::Index result;
20141
20142   arg1 = (Dali::PropertyNotification *)jarg1;
20143   {
20144     try {
20145       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20146     } catch (std::out_of_range& e) {
20147       {
20148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20149       };
20150     } catch (std::exception& e) {
20151       {
20152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20153       };
20154     } catch (Dali::DaliException e) {
20155       {
20156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20157       };
20158     } catch (...) {
20159       {
20160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20161       };
20162     }
20163   }
20164
20165   jresult = result;
20166   return jresult;
20167 }
20168
20169
20170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20171   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20172   Dali::PropertyNotification::NotifyMode arg2 ;
20173
20174   arg1 = (Dali::PropertyNotification *)jarg1;
20175   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20176   {
20177     try {
20178       (arg1)->SetNotifyMode(arg2);
20179     } catch (std::out_of_range& e) {
20180       {
20181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20182       };
20183     } catch (std::exception& e) {
20184       {
20185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20186       };
20187     } catch (Dali::DaliException e) {
20188       {
20189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20190       };
20191     } catch (...) {
20192       {
20193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20194       };
20195     }
20196   }
20197
20198 }
20199
20200
20201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20202   int jresult ;
20203   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20204   Dali::PropertyNotification::NotifyMode result;
20205
20206   arg1 = (Dali::PropertyNotification *)jarg1;
20207   {
20208     try {
20209       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20210     } catch (std::out_of_range& e) {
20211       {
20212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20213       };
20214     } catch (std::exception& e) {
20215       {
20216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20217       };
20218     } catch (Dali::DaliException e) {
20219       {
20220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20221       };
20222     } catch (...) {
20223       {
20224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20225       };
20226     }
20227   }
20228
20229   jresult = (int)result;
20230   return jresult;
20231 }
20232
20233
20234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20235   unsigned int jresult ;
20236   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20237   bool result;
20238
20239   arg1 = (Dali::PropertyNotification *)jarg1;
20240   {
20241     try {
20242       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20243     } catch (std::out_of_range& e) {
20244       {
20245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20246       };
20247     } catch (std::exception& e) {
20248       {
20249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20250       };
20251     } catch (Dali::DaliException e) {
20252       {
20253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20254       };
20255     } catch (...) {
20256       {
20257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20258       };
20259     }
20260   }
20261
20262   jresult = result;
20263   return jresult;
20264 }
20265
20266
20267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20268   void * jresult ;
20269   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20270   Dali::PropertyNotifySignalType *result = 0 ;
20271
20272   arg1 = (Dali::PropertyNotification *)jarg1;
20273   {
20274     try {
20275       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20276     } catch (std::out_of_range& e) {
20277       {
20278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20279       };
20280     } catch (std::exception& e) {
20281       {
20282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20283       };
20284     } catch (Dali::DaliException e) {
20285       {
20286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20287       };
20288     } catch (...) {
20289       {
20290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20291       };
20292     }
20293   }
20294
20295   jresult = (void *)result;
20296   return jresult;
20297 }
20298
20299
20300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20301   void * jresult ;
20302   Dali::Handle *result = 0 ;
20303
20304   {
20305     try {
20306       result = (Dali::Handle *)new Dali::Handle();
20307     } catch (std::out_of_range& e) {
20308       {
20309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20310       };
20311     } catch (std::exception& e) {
20312       {
20313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20314       };
20315     } catch (Dali::DaliException e) {
20316       {
20317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20318       };
20319     } catch (...) {
20320       {
20321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20322       };
20323     }
20324   }
20325
20326   jresult = (void *)result;
20327   return jresult;
20328 }
20329
20330
20331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20332   void * jresult ;
20333   Dali::Handle result;
20334
20335   {
20336     try {
20337       result = Dali::Handle::New();
20338     } catch (std::out_of_range& e) {
20339       {
20340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20341       };
20342     } catch (std::exception& e) {
20343       {
20344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20345       };
20346     } catch (Dali::DaliException e) {
20347       {
20348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20349       };
20350     } catch (...) {
20351       {
20352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20353       };
20354     }
20355   }
20356
20357   jresult = new Dali::Handle((const Dali::Handle &)result);
20358   return jresult;
20359 }
20360
20361
20362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20363   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20364
20365   arg1 = (Dali::Handle *)jarg1;
20366   {
20367     try {
20368       delete arg1;
20369     } catch (std::out_of_range& e) {
20370       {
20371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20372       };
20373     } catch (std::exception& e) {
20374       {
20375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20376       };
20377     } catch (Dali::DaliException e) {
20378       {
20379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20380       };
20381     } catch (...) {
20382       {
20383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20384       };
20385     }
20386   }
20387
20388 }
20389
20390
20391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20392   void * jresult ;
20393   Dali::Handle *arg1 = 0 ;
20394   Dali::Handle *result = 0 ;
20395
20396   arg1 = (Dali::Handle *)jarg1;
20397   if (!arg1) {
20398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20399     return 0;
20400   }
20401   {
20402     try {
20403       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20404     } catch (std::out_of_range& e) {
20405       {
20406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20407       };
20408     } catch (std::exception& e) {
20409       {
20410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20411       };
20412     } catch (Dali::DaliException e) {
20413       {
20414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20415       };
20416     } catch (...) {
20417       {
20418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20419       };
20420     }
20421   }
20422
20423   jresult = (void *)result;
20424   return jresult;
20425 }
20426
20427
20428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20429   void * jresult ;
20430   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20431   Dali::Handle *arg2 = 0 ;
20432   Dali::Handle *result = 0 ;
20433
20434   arg1 = (Dali::Handle *)jarg1;
20435   arg2 = (Dali::Handle *)jarg2;
20436   if (!arg2) {
20437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20438     return 0;
20439   }
20440   {
20441     try {
20442       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20443     } catch (std::out_of_range& e) {
20444       {
20445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20446       };
20447     } catch (std::exception& e) {
20448       {
20449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20450       };
20451     } catch (Dali::DaliException e) {
20452       {
20453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20454       };
20455     } catch (...) {
20456       {
20457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20458       };
20459     }
20460   }
20461
20462   jresult = (void *)result;
20463   return jresult;
20464 }
20465
20466
20467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20468   void * jresult ;
20469   Dali::BaseHandle arg1 ;
20470   Dali::BaseHandle *argp1 ;
20471   Dali::Handle result;
20472
20473   argp1 = (Dali::BaseHandle *)jarg1;
20474   if (!argp1) {
20475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20476     return 0;
20477   }
20478   arg1 = *argp1;
20479   {
20480     try {
20481       result = Dali::Handle::DownCast(arg1);
20482     } catch (std::out_of_range& e) {
20483       {
20484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20485       };
20486     } catch (std::exception& e) {
20487       {
20488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20489       };
20490     } catch (Dali::DaliException e) {
20491       {
20492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20493       };
20494     } catch (...) {
20495       {
20496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20497       };
20498     }
20499   }
20500
20501   jresult = new Dali::Handle((const Dali::Handle &)result);
20502   return jresult;
20503 }
20504
20505
20506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20507   unsigned int jresult ;
20508   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20509   Dali::Handle::Capability arg2 ;
20510   bool result;
20511
20512   arg1 = (Dali::Handle *)jarg1;
20513   arg2 = (Dali::Handle::Capability)jarg2;
20514   {
20515     try {
20516       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20517     } catch (std::out_of_range& e) {
20518       {
20519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20520       };
20521     } catch (std::exception& e) {
20522       {
20523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20524       };
20525     } catch (Dali::DaliException e) {
20526       {
20527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20528       };
20529     } catch (...) {
20530       {
20531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20532       };
20533     }
20534   }
20535
20536   jresult = result;
20537   return jresult;
20538 }
20539
20540
20541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20542   unsigned int jresult ;
20543   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20544   unsigned int result;
20545
20546   arg1 = (Dali::Handle *)jarg1;
20547   {
20548     try {
20549       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20550     } catch (std::out_of_range& e) {
20551       {
20552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20553       };
20554     } catch (std::exception& e) {
20555       {
20556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20557       };
20558     } catch (Dali::DaliException e) {
20559       {
20560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20561       };
20562     } catch (...) {
20563       {
20564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20565       };
20566     }
20567   }
20568
20569   jresult = result;
20570   return jresult;
20571 }
20572
20573
20574 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20575   char * jresult ;
20576   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20577   Dali::Property::Index arg2 ;
20578   std::string result;
20579
20580   arg1 = (Dali::Handle *)jarg1;
20581   arg2 = (Dali::Property::Index)jarg2;
20582   {
20583     try {
20584       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20585     } catch (std::out_of_range& e) {
20586       {
20587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20588       };
20589     } catch (std::exception& e) {
20590       {
20591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20592       };
20593     } catch (Dali::DaliException e) {
20594       {
20595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20596       };
20597     } catch (...) {
20598       {
20599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20600       };
20601     }
20602   }
20603
20604   jresult = SWIG_csharp_string_callback((&result)->c_str());
20605   return jresult;
20606 }
20607
20608
20609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20610   int jresult ;
20611   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20612   std::string *arg2 = 0 ;
20613   Dali::Property::Index result;
20614
20615   arg1 = (Dali::Handle *)jarg1;
20616   if (!jarg2) {
20617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20618     return 0;
20619   }
20620   std::string arg2_str(jarg2);
20621   arg2 = &arg2_str;
20622   {
20623     try {
20624       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20625     } catch (std::out_of_range& e) {
20626       {
20627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20628       };
20629     } catch (std::exception& e) {
20630       {
20631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20632       };
20633     } catch (Dali::DaliException e) {
20634       {
20635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20636       };
20637     } catch (...) {
20638       {
20639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20640       };
20641     }
20642   }
20643
20644   jresult = result;
20645
20646   //argout typemap for const std::string&
20647
20648   return jresult;
20649 }
20650
20651
20652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20653   unsigned int jresult ;
20654   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20655   Dali::Property::Index arg2 ;
20656   bool result;
20657
20658   arg1 = (Dali::Handle *)jarg1;
20659   arg2 = (Dali::Property::Index)jarg2;
20660   {
20661     try {
20662       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20663     } catch (std::out_of_range& e) {
20664       {
20665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20666       };
20667     } catch (std::exception& e) {
20668       {
20669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20670       };
20671     } catch (Dali::DaliException e) {
20672       {
20673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20674       };
20675     } catch (...) {
20676       {
20677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20678       };
20679     }
20680   }
20681
20682   jresult = result;
20683   return jresult;
20684 }
20685
20686
20687 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20688   unsigned int jresult ;
20689   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20690   Dali::Property::Index arg2 ;
20691   bool result;
20692
20693   arg1 = (Dali::Handle *)jarg1;
20694   arg2 = (Dali::Property::Index)jarg2;
20695   {
20696     try {
20697       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20698     } catch (std::out_of_range& e) {
20699       {
20700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20701       };
20702     } catch (std::exception& e) {
20703       {
20704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20705       };
20706     } catch (Dali::DaliException e) {
20707       {
20708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20709       };
20710     } catch (...) {
20711       {
20712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20713       };
20714     }
20715   }
20716
20717   jresult = result;
20718   return jresult;
20719 }
20720
20721
20722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20723   unsigned int jresult ;
20724   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20725   Dali::Property::Index arg2 ;
20726   bool result;
20727
20728   arg1 = (Dali::Handle *)jarg1;
20729   arg2 = (Dali::Property::Index)jarg2;
20730   {
20731     try {
20732       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20733     } catch (std::out_of_range& e) {
20734       {
20735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20736       };
20737     } catch (std::exception& e) {
20738       {
20739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20740       };
20741     } catch (Dali::DaliException e) {
20742       {
20743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20744       };
20745     } catch (...) {
20746       {
20747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20748       };
20749     }
20750   }
20751
20752   jresult = result;
20753   return jresult;
20754 }
20755
20756
20757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20758   int jresult ;
20759   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20760   Dali::Property::Index arg2 ;
20761   Dali::Property::Type result;
20762
20763   arg1 = (Dali::Handle *)jarg1;
20764   arg2 = (Dali::Property::Index)jarg2;
20765   {
20766     try {
20767       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20768     } catch (std::out_of_range& e) {
20769       {
20770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20771       };
20772     } catch (std::exception& e) {
20773       {
20774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20775       };
20776     } catch (Dali::DaliException e) {
20777       {
20778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20779       };
20780     } catch (...) {
20781       {
20782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20783       };
20784     }
20785   }
20786
20787   jresult = (int)result;
20788   return jresult;
20789 }
20790
20791
20792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20793   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20794   Dali::Property::Index arg2 ;
20795   Dali::Property::Value *arg3 = 0 ;
20796
20797   arg1 = (Dali::Handle *)jarg1;
20798   arg2 = (Dali::Property::Index)jarg2;
20799   arg3 = (Dali::Property::Value *)jarg3;
20800   if (!arg3) {
20801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20802     return ;
20803   }
20804   {
20805     try {
20806       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20807     } catch (std::out_of_range& e) {
20808       {
20809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20810       };
20811     } catch (std::exception& e) {
20812       {
20813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20814       };
20815     } catch (Dali::DaliException e) {
20816       {
20817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20818       };
20819     } catch (...) {
20820       {
20821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20822       };
20823     }
20824   }
20825
20826 }
20827
20828
20829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20830   int jresult ;
20831   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20832   std::string *arg2 = 0 ;
20833   Dali::Property::Value *arg3 = 0 ;
20834   Dali::Property::Index result;
20835
20836   arg1 = (Dali::Handle *)jarg1;
20837   if (!jarg2) {
20838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20839     return 0;
20840   }
20841   std::string arg2_str(jarg2);
20842   arg2 = &arg2_str;
20843   arg3 = (Dali::Property::Value *)jarg3;
20844   if (!arg3) {
20845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20846     return 0;
20847   }
20848   {
20849     try {
20850       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20851     } catch (std::out_of_range& e) {
20852       {
20853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20854       };
20855     } catch (std::exception& e) {
20856       {
20857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20858       };
20859     } catch (Dali::DaliException e) {
20860       {
20861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20862       };
20863     } catch (...) {
20864       {
20865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20866       };
20867     }
20868   }
20869
20870   jresult = result;
20871
20872   //argout typemap for const std::string&
20873
20874   return jresult;
20875 }
20876
20877
20878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20879   int jresult ;
20880   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20881   std::string *arg2 = 0 ;
20882   Dali::Property::Value *arg3 = 0 ;
20883   Dali::Property::AccessMode arg4 ;
20884   Dali::Property::Index result;
20885
20886   arg1 = (Dali::Handle *)jarg1;
20887   if (!jarg2) {
20888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20889     return 0;
20890   }
20891   std::string arg2_str(jarg2);
20892   arg2 = &arg2_str;
20893   arg3 = (Dali::Property::Value *)jarg3;
20894   if (!arg3) {
20895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20896     return 0;
20897   }
20898   arg4 = (Dali::Property::AccessMode)jarg4;
20899   {
20900     try {
20901       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20902     } catch (std::out_of_range& e) {
20903       {
20904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20905       };
20906     } catch (std::exception& e) {
20907       {
20908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20909       };
20910     } catch (Dali::DaliException e) {
20911       {
20912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20913       };
20914     } catch (...) {
20915       {
20916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20917       };
20918     }
20919   }
20920
20921   jresult = result;
20922
20923   //argout typemap for const std::string&
20924
20925   return jresult;
20926 }
20927
20928
20929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20930   void * jresult ;
20931   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20932   Dali::Property::Index arg2 ;
20933   Dali::Property::Value result;
20934
20935   arg1 = (Dali::Handle *)jarg1;
20936   arg2 = (Dali::Property::Index)jarg2;
20937   {
20938     try {
20939       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20940     } catch (std::out_of_range& e) {
20941       {
20942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20943       };
20944     } catch (std::exception& e) {
20945       {
20946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20947       };
20948     } catch (Dali::DaliException e) {
20949       {
20950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20951       };
20952     } catch (...) {
20953       {
20954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20955       };
20956     }
20957   }
20958
20959   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20960   return jresult;
20961 }
20962
20963
20964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20965   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20966   Dali::Property::IndexContainer *arg2 = 0 ;
20967
20968   arg1 = (Dali::Handle *)jarg1;
20969   arg2 = (Dali::Property::IndexContainer *)jarg2;
20970   if (!arg2) {
20971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20972     return ;
20973   }
20974   {
20975     try {
20976       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20977     } catch (std::out_of_range& e) {
20978       {
20979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20980       };
20981     } catch (std::exception& e) {
20982       {
20983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20984       };
20985     } catch (Dali::DaliException e) {
20986       {
20987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20988       };
20989     } catch (...) {
20990       {
20991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20992       };
20993     }
20994   }
20995
20996 }
20997
20998
20999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
21000   void * jresult ;
21001   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21002   Dali::Property::Index arg2 ;
21003   Dali::PropertyCondition *arg3 = 0 ;
21004   Dali::PropertyNotification result;
21005
21006   arg1 = (Dali::Handle *)jarg1;
21007   arg2 = (Dali::Property::Index)jarg2;
21008   arg3 = (Dali::PropertyCondition *)jarg3;
21009   if (!arg3) {
21010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
21011     return 0;
21012   }
21013   {
21014     try {
21015       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
21016     } catch (std::out_of_range& e) {
21017       {
21018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21019       };
21020     } catch (std::exception& e) {
21021       {
21022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21023       };
21024     } catch (Dali::DaliException e) {
21025       {
21026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21027       };
21028     } catch (...) {
21029       {
21030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21031       };
21032     }
21033   }
21034
21035   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21036   return jresult;
21037 }
21038
21039
21040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
21041   void * jresult ;
21042   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21043   Dali::Property::Index arg2 ;
21044   int arg3 ;
21045   Dali::PropertyCondition *arg4 = 0 ;
21046   Dali::PropertyNotification result;
21047
21048   arg1 = (Dali::Handle *)jarg1;
21049   arg2 = (Dali::Property::Index)jarg2;
21050   arg3 = (int)jarg3;
21051   arg4 = (Dali::PropertyCondition *)jarg4;
21052   if (!arg4) {
21053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
21054     return 0;
21055   }
21056   {
21057     try {
21058       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
21059     } catch (std::out_of_range& e) {
21060       {
21061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21062       };
21063     } catch (std::exception& e) {
21064       {
21065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21066       };
21067     } catch (Dali::DaliException e) {
21068       {
21069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21070       };
21071     } catch (...) {
21072       {
21073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21074       };
21075     }
21076   }
21077
21078   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21079   return jresult;
21080 }
21081
21082
21083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21084   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21085   Dali::PropertyNotification arg2 ;
21086   Dali::PropertyNotification *argp2 ;
21087
21088   arg1 = (Dali::Handle *)jarg1;
21089   argp2 = (Dali::PropertyNotification *)jarg2;
21090   if (!argp2) {
21091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21092     return ;
21093   }
21094   arg2 = *argp2;
21095   {
21096     try {
21097       (arg1)->RemovePropertyNotification(arg2);
21098     } catch (std::out_of_range& e) {
21099       {
21100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21101       };
21102     } catch (std::exception& e) {
21103       {
21104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21105       };
21106     } catch (Dali::DaliException e) {
21107       {
21108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21109       };
21110     } catch (...) {
21111       {
21112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21113       };
21114     }
21115   }
21116
21117 }
21118
21119
21120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21121   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21122
21123   arg1 = (Dali::Handle *)jarg1;
21124   {
21125     try {
21126       (arg1)->RemovePropertyNotifications();
21127     } catch (std::out_of_range& e) {
21128       {
21129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21130       };
21131     } catch (std::exception& e) {
21132       {
21133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21134       };
21135     } catch (Dali::DaliException e) {
21136       {
21137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21138       };
21139     } catch (...) {
21140       {
21141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21142       };
21143     }
21144   }
21145
21146 }
21147
21148
21149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21150   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21151
21152   arg1 = (Dali::Handle *)jarg1;
21153   {
21154     try {
21155       (arg1)->RemoveConstraints();
21156     } catch (std::out_of_range& e) {
21157       {
21158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21159       };
21160     } catch (std::exception& e) {
21161       {
21162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21163       };
21164     } catch (Dali::DaliException e) {
21165       {
21166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21167       };
21168     } catch (...) {
21169       {
21170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21171       };
21172     }
21173   }
21174
21175 }
21176
21177
21178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21179   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21180   unsigned int arg2 ;
21181
21182   arg1 = (Dali::Handle *)jarg1;
21183   arg2 = (unsigned int)jarg2;
21184   {
21185     try {
21186       (arg1)->RemoveConstraints(arg2);
21187     } catch (std::out_of_range& e) {
21188       {
21189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21190       };
21191     } catch (std::exception& e) {
21192       {
21193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21194       };
21195     } catch (Dali::DaliException e) {
21196       {
21197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21198       };
21199     } catch (...) {
21200       {
21201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21202       };
21203     }
21204   }
21205
21206 }
21207
21208
21209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21210   int jresult ;
21211   Dali::Property::Index result;
21212
21213   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21214   jresult = result;
21215   return jresult;
21216 }
21217
21218
21219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21220   void * jresult ;
21221   Dali::Handle result;
21222
21223   {
21224     try {
21225       result = Dali::WeightObject::New();
21226     } catch (std::out_of_range& e) {
21227       {
21228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21229       };
21230     } catch (std::exception& e) {
21231       {
21232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21233       };
21234     } catch (Dali::DaliException e) {
21235       {
21236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21237       };
21238     } catch (...) {
21239       {
21240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21241       };
21242     }
21243   }
21244
21245   jresult = new Dali::Handle((const Dali::Handle &)result);
21246   return jresult;
21247 }
21248
21249
21250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21251   void * jresult ;
21252   Dali::TypeInfo *result = 0 ;
21253
21254   {
21255     try {
21256       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21257     } catch (std::out_of_range& e) {
21258       {
21259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21260       };
21261     } catch (std::exception& e) {
21262       {
21263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21264       };
21265     } catch (Dali::DaliException e) {
21266       {
21267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21268       };
21269     } catch (...) {
21270       {
21271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21272       };
21273     }
21274   }
21275
21276   jresult = (void *)result;
21277   return jresult;
21278 }
21279
21280
21281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21282   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21283
21284   arg1 = (Dali::TypeInfo *)jarg1;
21285   {
21286     try {
21287       delete arg1;
21288     } catch (std::out_of_range& e) {
21289       {
21290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21291       };
21292     } catch (std::exception& e) {
21293       {
21294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21295       };
21296     } catch (Dali::DaliException e) {
21297       {
21298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21299       };
21300     } catch (...) {
21301       {
21302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21303       };
21304     }
21305   }
21306
21307 }
21308
21309
21310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21311   void * jresult ;
21312   Dali::TypeInfo *arg1 = 0 ;
21313   Dali::TypeInfo *result = 0 ;
21314
21315   arg1 = (Dali::TypeInfo *)jarg1;
21316   if (!arg1) {
21317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21318     return 0;
21319   }
21320   {
21321     try {
21322       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
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 = (void *)result;
21343   return jresult;
21344 }
21345
21346
21347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21348   void * jresult ;
21349   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21350   Dali::TypeInfo *arg2 = 0 ;
21351   Dali::TypeInfo *result = 0 ;
21352
21353   arg1 = (Dali::TypeInfo *)jarg1;
21354   arg2 = (Dali::TypeInfo *)jarg2;
21355   if (!arg2) {
21356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21357     return 0;
21358   }
21359   {
21360     try {
21361       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21362     } catch (std::out_of_range& e) {
21363       {
21364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21365       };
21366     } catch (std::exception& e) {
21367       {
21368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21369       };
21370     } catch (Dali::DaliException e) {
21371       {
21372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21373       };
21374     } catch (...) {
21375       {
21376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21377       };
21378     }
21379   }
21380
21381   jresult = (void *)result;
21382   return jresult;
21383 }
21384
21385
21386 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21387   char * jresult ;
21388   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21389   std::string *result = 0 ;
21390
21391   arg1 = (Dali::TypeInfo *)jarg1;
21392   {
21393     try {
21394       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21395     } catch (std::out_of_range& e) {
21396       {
21397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21398       };
21399     } catch (std::exception& e) {
21400       {
21401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21402       };
21403     } catch (Dali::DaliException e) {
21404       {
21405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21406       };
21407     } catch (...) {
21408       {
21409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21410       };
21411     }
21412   }
21413
21414   jresult = SWIG_csharp_string_callback(result->c_str());
21415   return jresult;
21416 }
21417
21418
21419 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21420   char * jresult ;
21421   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21422   std::string *result = 0 ;
21423
21424   arg1 = (Dali::TypeInfo *)jarg1;
21425   {
21426     try {
21427       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21428     } catch (std::out_of_range& e) {
21429       {
21430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21431       };
21432     } catch (std::exception& e) {
21433       {
21434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21435       };
21436     } catch (Dali::DaliException e) {
21437       {
21438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21439       };
21440     } catch (...) {
21441       {
21442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21443       };
21444     }
21445   }
21446
21447   jresult = SWIG_csharp_string_callback(result->c_str());
21448   return jresult;
21449 }
21450
21451
21452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21453   void * jresult ;
21454   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21455   Dali::BaseHandle result;
21456
21457   arg1 = (Dali::TypeInfo *)jarg1;
21458   {
21459     try {
21460       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21461     } catch (std::out_of_range& e) {
21462       {
21463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21464       };
21465     } catch (std::exception& e) {
21466       {
21467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21468       };
21469     } catch (Dali::DaliException e) {
21470       {
21471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21472       };
21473     } catch (...) {
21474       {
21475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21476       };
21477     }
21478   }
21479
21480   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21481   return jresult;
21482 }
21483
21484
21485 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21486   unsigned long jresult ;
21487   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21488   size_t result;
21489
21490   arg1 = (Dali::TypeInfo *)jarg1;
21491   {
21492     try {
21493       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21494     } catch (std::out_of_range& e) {
21495       {
21496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21497       };
21498     } catch (std::exception& e) {
21499       {
21500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21501       };
21502     } catch (Dali::DaliException e) {
21503       {
21504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21505       };
21506     } catch (...) {
21507       {
21508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21509       };
21510     }
21511   }
21512
21513   jresult = (unsigned long)result;
21514   return jresult;
21515 }
21516
21517
21518 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21519   char * jresult ;
21520   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21521   size_t arg2 ;
21522   std::string result;
21523
21524   arg1 = (Dali::TypeInfo *)jarg1;
21525   arg2 = (size_t)jarg2;
21526   {
21527     try {
21528       result = (arg1)->GetActionName(arg2);
21529     } catch (std::out_of_range& e) {
21530       {
21531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21532       };
21533     } catch (std::exception& e) {
21534       {
21535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21536       };
21537     } catch (Dali::DaliException e) {
21538       {
21539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21540       };
21541     } catch (...) {
21542       {
21543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21544       };
21545     }
21546   }
21547
21548   jresult = SWIG_csharp_string_callback((&result)->c_str());
21549   return jresult;
21550 }
21551
21552
21553 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21554   unsigned long jresult ;
21555   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21556   size_t result;
21557
21558   arg1 = (Dali::TypeInfo *)jarg1;
21559   {
21560     try {
21561       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21562     } catch (std::out_of_range& e) {
21563       {
21564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21565       };
21566     } catch (std::exception& e) {
21567       {
21568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21569       };
21570     } catch (Dali::DaliException e) {
21571       {
21572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21573       };
21574     } catch (...) {
21575       {
21576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21577       };
21578     }
21579   }
21580
21581   jresult = (unsigned long)result;
21582   return jresult;
21583 }
21584
21585
21586 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21587   char * jresult ;
21588   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21589   size_t arg2 ;
21590   std::string result;
21591
21592   arg1 = (Dali::TypeInfo *)jarg1;
21593   arg2 = (size_t)jarg2;
21594   {
21595     try {
21596       result = (arg1)->GetSignalName(arg2);
21597     } catch (std::out_of_range& e) {
21598       {
21599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21600       };
21601     } catch (std::exception& e) {
21602       {
21603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21604       };
21605     } catch (Dali::DaliException e) {
21606       {
21607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21608       };
21609     } catch (...) {
21610       {
21611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21612       };
21613     }
21614   }
21615
21616   jresult = SWIG_csharp_string_callback((&result)->c_str());
21617   return jresult;
21618 }
21619
21620
21621 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21622   unsigned long jresult ;
21623   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21624   size_t result;
21625
21626   arg1 = (Dali::TypeInfo *)jarg1;
21627   {
21628     try {
21629       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21630     } catch (std::out_of_range& e) {
21631       {
21632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21633       };
21634     } catch (std::exception& e) {
21635       {
21636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21637       };
21638     } catch (Dali::DaliException e) {
21639       {
21640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21641       };
21642     } catch (...) {
21643       {
21644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21645       };
21646     }
21647   }
21648
21649   jresult = (unsigned long)result;
21650   return jresult;
21651 }
21652
21653
21654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21655   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21656   Dali::Property::IndexContainer *arg2 = 0 ;
21657
21658   arg1 = (Dali::TypeInfo *)jarg1;
21659   arg2 = (Dali::Property::IndexContainer *)jarg2;
21660   if (!arg2) {
21661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21662     return ;
21663   }
21664   {
21665     try {
21666       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21667     } catch (std::out_of_range& e) {
21668       {
21669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21670       };
21671     } catch (std::exception& e) {
21672       {
21673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21674       };
21675     } catch (Dali::DaliException e) {
21676       {
21677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21678       };
21679     } catch (...) {
21680       {
21681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21682       };
21683     }
21684   }
21685
21686 }
21687
21688
21689 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21690   char * jresult ;
21691   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21692   Dali::Property::Index arg2 ;
21693   std::string *result = 0 ;
21694
21695   arg1 = (Dali::TypeInfo *)jarg1;
21696   arg2 = (Dali::Property::Index)jarg2;
21697   {
21698     try {
21699       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21700     } catch (std::out_of_range& e) {
21701       {
21702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21703       };
21704     } catch (std::exception& e) {
21705       {
21706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21707       };
21708     } catch (Dali::DaliException e) {
21709       {
21710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21711       };
21712     } catch (...) {
21713       {
21714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21715       };
21716     }
21717   }
21718
21719   jresult = SWIG_csharp_string_callback(result->c_str());
21720   return jresult;
21721 }
21722
21723
21724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21725   void * jresult ;
21726   Dali::TypeRegistry result;
21727
21728   {
21729     try {
21730       result = Dali::TypeRegistry::Get();
21731     } catch (std::out_of_range& e) {
21732       {
21733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21734       };
21735     } catch (std::exception& e) {
21736       {
21737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21738       };
21739     } catch (Dali::DaliException e) {
21740       {
21741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21742       };
21743     } catch (...) {
21744       {
21745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21746       };
21747     }
21748   }
21749
21750   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21751   return jresult;
21752 }
21753
21754
21755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21756   void * jresult ;
21757   Dali::TypeRegistry *result = 0 ;
21758
21759   {
21760     try {
21761       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21762     } catch (std::out_of_range& e) {
21763       {
21764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21765       };
21766     } catch (std::exception& e) {
21767       {
21768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21769       };
21770     } catch (Dali::DaliException e) {
21771       {
21772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21773       };
21774     } catch (...) {
21775       {
21776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21777       };
21778     }
21779   }
21780
21781   jresult = (void *)result;
21782   return jresult;
21783 }
21784
21785
21786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21787   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21788
21789   arg1 = (Dali::TypeRegistry *)jarg1;
21790   {
21791     try {
21792       delete arg1;
21793     } catch (std::out_of_range& e) {
21794       {
21795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21796       };
21797     } catch (std::exception& e) {
21798       {
21799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21800       };
21801     } catch (Dali::DaliException e) {
21802       {
21803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21804       };
21805     } catch (...) {
21806       {
21807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21808       };
21809     }
21810   }
21811
21812 }
21813
21814
21815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21816   void * jresult ;
21817   Dali::TypeRegistry *arg1 = 0 ;
21818   Dali::TypeRegistry *result = 0 ;
21819
21820   arg1 = (Dali::TypeRegistry *)jarg1;
21821   if (!arg1) {
21822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21823     return 0;
21824   }
21825   {
21826     try {
21827       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21828     } catch (std::out_of_range& e) {
21829       {
21830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21831       };
21832     } catch (std::exception& e) {
21833       {
21834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21835       };
21836     } catch (Dali::DaliException e) {
21837       {
21838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21839       };
21840     } catch (...) {
21841       {
21842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21843       };
21844     }
21845   }
21846
21847   jresult = (void *)result;
21848   return jresult;
21849 }
21850
21851
21852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21853   void * jresult ;
21854   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21855   Dali::TypeRegistry *arg2 = 0 ;
21856   Dali::TypeRegistry *result = 0 ;
21857
21858   arg1 = (Dali::TypeRegistry *)jarg1;
21859   arg2 = (Dali::TypeRegistry *)jarg2;
21860   if (!arg2) {
21861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21862     return 0;
21863   }
21864   {
21865     try {
21866       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21867     } catch (std::out_of_range& e) {
21868       {
21869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21870       };
21871     } catch (std::exception& e) {
21872       {
21873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21874       };
21875     } catch (Dali::DaliException e) {
21876       {
21877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21878       };
21879     } catch (...) {
21880       {
21881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21882       };
21883     }
21884   }
21885
21886   jresult = (void *)result;
21887   return jresult;
21888 }
21889
21890
21891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21892   void * jresult ;
21893   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21894   std::string *arg2 = 0 ;
21895   Dali::TypeInfo result;
21896
21897   arg1 = (Dali::TypeRegistry *)jarg1;
21898   if (!jarg2) {
21899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21900     return 0;
21901   }
21902   std::string arg2_str(jarg2);
21903   arg2 = &arg2_str;
21904   {
21905     try {
21906       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21907     } catch (std::out_of_range& e) {
21908       {
21909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21910       };
21911     } catch (std::exception& e) {
21912       {
21913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21914       };
21915     } catch (Dali::DaliException e) {
21916       {
21917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21918       };
21919     } catch (...) {
21920       {
21921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21922       };
21923     }
21924   }
21925
21926   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21927
21928   //argout typemap for const std::string&
21929
21930   return jresult;
21931 }
21932
21933
21934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21935   void * jresult ;
21936   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21937   std::type_info *arg2 = 0 ;
21938   Dali::TypeInfo result;
21939
21940   arg1 = (Dali::TypeRegistry *)jarg1;
21941   arg2 = (std::type_info *)jarg2;
21942   if (!arg2) {
21943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21944     return 0;
21945   }
21946   {
21947     try {
21948       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21949     } catch (std::out_of_range& e) {
21950       {
21951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21952       };
21953     } catch (std::exception& e) {
21954       {
21955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21956       };
21957     } catch (Dali::DaliException e) {
21958       {
21959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21960       };
21961     } catch (...) {
21962       {
21963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21964       };
21965     }
21966   }
21967
21968   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21969   return jresult;
21970 }
21971
21972
21973 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21974   unsigned long jresult ;
21975   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21976   size_t result;
21977
21978   arg1 = (Dali::TypeRegistry *)jarg1;
21979   {
21980     try {
21981       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21982     } catch (std::out_of_range& e) {
21983       {
21984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21985       };
21986     } catch (std::exception& e) {
21987       {
21988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21989       };
21990     } catch (Dali::DaliException e) {
21991       {
21992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21993       };
21994     } catch (...) {
21995       {
21996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21997       };
21998     }
21999   }
22000
22001   jresult = (unsigned long)result;
22002   return jresult;
22003 }
22004
22005
22006 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
22007   char * jresult ;
22008   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
22009   size_t arg2 ;
22010   std::string result;
22011
22012   arg1 = (Dali::TypeRegistry *)jarg1;
22013   arg2 = (size_t)jarg2;
22014   {
22015     try {
22016       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
22017     } catch (std::out_of_range& e) {
22018       {
22019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22020       };
22021     } catch (std::exception& e) {
22022       {
22023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22024       };
22025     } catch (Dali::DaliException e) {
22026       {
22027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22028       };
22029     } catch (...) {
22030       {
22031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22032       };
22033     }
22034   }
22035
22036   jresult = SWIG_csharp_string_callback((&result)->c_str());
22037   return jresult;
22038 }
22039
22040
22041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22042   void * jresult ;
22043   std::type_info *arg1 = 0 ;
22044   std::type_info *arg2 = 0 ;
22045   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22046   Dali::TypeRegistration *result = 0 ;
22047
22048   arg1 = (std::type_info *)jarg1;
22049   if (!arg1) {
22050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22051     return 0;
22052   }
22053   arg2 = (std::type_info *)jarg2;
22054   if (!arg2) {
22055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22056     return 0;
22057   }
22058   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22059   {
22060     try {
22061       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
22062     } catch (std::out_of_range& e) {
22063       {
22064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22065       };
22066     } catch (std::exception& e) {
22067       {
22068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22069       };
22070     } catch (Dali::DaliException e) {
22071       {
22072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22073       };
22074     } catch (...) {
22075       {
22076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22077       };
22078     }
22079   }
22080
22081   jresult = (void *)result;
22082   return jresult;
22083 }
22084
22085
22086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22087   void * jresult ;
22088   std::type_info *arg1 = 0 ;
22089   std::type_info *arg2 = 0 ;
22090   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22091   bool arg4 ;
22092   Dali::TypeRegistration *result = 0 ;
22093
22094   arg1 = (std::type_info *)jarg1;
22095   if (!arg1) {
22096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22097     return 0;
22098   }
22099   arg2 = (std::type_info *)jarg2;
22100   if (!arg2) {
22101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22102     return 0;
22103   }
22104   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22105   arg4 = jarg4 ? true : false;
22106   {
22107     try {
22108       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22109     } catch (std::out_of_range& e) {
22110       {
22111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22112       };
22113     } catch (std::exception& e) {
22114       {
22115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22116       };
22117     } catch (Dali::DaliException e) {
22118       {
22119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22120       };
22121     } catch (...) {
22122       {
22123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22124       };
22125     }
22126   }
22127
22128   jresult = (void *)result;
22129   return jresult;
22130 }
22131
22132
22133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22134   void * jresult ;
22135   std::string *arg1 = 0 ;
22136   std::type_info *arg2 = 0 ;
22137   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22138   Dali::TypeRegistration *result = 0 ;
22139
22140   if (!jarg1) {
22141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22142     return 0;
22143   }
22144   std::string arg1_str(jarg1);
22145   arg1 = &arg1_str;
22146   arg2 = (std::type_info *)jarg2;
22147   if (!arg2) {
22148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22149     return 0;
22150   }
22151   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22152   {
22153     try {
22154       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22155     } catch (std::out_of_range& e) {
22156       {
22157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22158       };
22159     } catch (std::exception& e) {
22160       {
22161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22162       };
22163     } catch (Dali::DaliException e) {
22164       {
22165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22166       };
22167     } catch (...) {
22168       {
22169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22170       };
22171     }
22172   }
22173
22174   jresult = (void *)result;
22175
22176   //argout typemap for const std::string&
22177
22178   return jresult;
22179 }
22180
22181
22182 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22183   char * jresult ;
22184   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22185   std::string result;
22186
22187   arg1 = (Dali::TypeRegistration *)jarg1;
22188   {
22189     try {
22190       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22191     } catch (std::out_of_range& e) {
22192       {
22193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22194       };
22195     } catch (std::exception& e) {
22196       {
22197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22198       };
22199     } catch (Dali::DaliException e) {
22200       {
22201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22202       };
22203     } catch (...) {
22204       {
22205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22206       };
22207     }
22208   }
22209
22210   jresult = SWIG_csharp_string_callback((&result)->c_str());
22211   return jresult;
22212 }
22213
22214
22215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22216   std::string *arg1 = 0 ;
22217   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22218
22219   if (!jarg1) {
22220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22221     return ;
22222   }
22223   std::string arg1_str(jarg1);
22224   arg1 = &arg1_str;
22225   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22226   {
22227     try {
22228       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22229     } catch (std::out_of_range& e) {
22230       {
22231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22232       };
22233     } catch (std::exception& e) {
22234       {
22235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22236       };
22237     } catch (Dali::DaliException e) {
22238       {
22239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22240       };
22241     } catch (...) {
22242       {
22243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22244       };
22245     }
22246   }
22247
22248
22249   //argout typemap for const std::string&
22250
22251 }
22252
22253
22254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22255   std::string *arg1 = 0 ;
22256   std::string *arg2 = 0 ;
22257   int arg3 ;
22258   Dali::Property::Type arg4 ;
22259   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22260   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22261
22262   if (!jarg1) {
22263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22264     return ;
22265   }
22266   std::string arg1_str(jarg1);
22267   arg1 = &arg1_str;
22268   if (!jarg2) {
22269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22270     return ;
22271   }
22272   std::string arg2_str(jarg2);
22273   arg2 = &arg2_str;
22274   arg3 = (int)jarg3;
22275   arg4 = (Dali::Property::Type)jarg4;
22276   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22277   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22278   {
22279     try {
22280       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22281     } catch (std::out_of_range& e) {
22282       {
22283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22284       };
22285     } catch (std::exception& e) {
22286       {
22287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22288       };
22289     } catch (Dali::DaliException e) {
22290       {
22291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22292       };
22293     } catch (...) {
22294       {
22295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22296       };
22297     }
22298   }
22299
22300
22301   //argout typemap for const std::string&
22302
22303
22304   //argout typemap for const std::string&
22305
22306 }
22307
22308
22309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22310   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22311
22312   arg1 = (Dali::TypeRegistration *)jarg1;
22313   {
22314     try {
22315       delete arg1;
22316     } catch (std::out_of_range& e) {
22317       {
22318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22319       };
22320     } catch (std::exception& e) {
22321       {
22322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22323       };
22324     } catch (Dali::DaliException e) {
22325       {
22326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22327       };
22328     } catch (...) {
22329       {
22330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22331       };
22332     }
22333   }
22334
22335 }
22336
22337
22338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22339   void * jresult ;
22340   Dali::TypeRegistration *arg1 = 0 ;
22341   std::string *arg2 = 0 ;
22342   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22343   Dali::SignalConnectorType *result = 0 ;
22344
22345   arg1 = (Dali::TypeRegistration *)jarg1;
22346   if (!arg1) {
22347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22348     return 0;
22349   }
22350   if (!jarg2) {
22351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22352     return 0;
22353   }
22354   std::string arg2_str(jarg2);
22355   arg2 = &arg2_str;
22356   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22357   {
22358     try {
22359       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22360     } catch (std::out_of_range& e) {
22361       {
22362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22363       };
22364     } catch (std::exception& e) {
22365       {
22366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22367       };
22368     } catch (Dali::DaliException e) {
22369       {
22370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22371       };
22372     } catch (...) {
22373       {
22374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22375       };
22376     }
22377   }
22378
22379   jresult = (void *)result;
22380
22381   //argout typemap for const std::string&
22382
22383   return jresult;
22384 }
22385
22386
22387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22388   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22389
22390   arg1 = (Dali::SignalConnectorType *)jarg1;
22391   {
22392     try {
22393       delete arg1;
22394     } catch (std::out_of_range& e) {
22395       {
22396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22397       };
22398     } catch (std::exception& e) {
22399       {
22400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22401       };
22402     } catch (Dali::DaliException e) {
22403       {
22404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22405       };
22406     } catch (...) {
22407       {
22408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22409       };
22410     }
22411   }
22412
22413 }
22414
22415
22416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22417   void * jresult ;
22418   Dali::TypeRegistration *arg1 = 0 ;
22419   std::string *arg2 = 0 ;
22420   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22421   Dali::TypeAction *result = 0 ;
22422
22423   arg1 = (Dali::TypeRegistration *)jarg1;
22424   if (!arg1) {
22425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22426     return 0;
22427   }
22428   if (!jarg2) {
22429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22430     return 0;
22431   }
22432   std::string arg2_str(jarg2);
22433   arg2 = &arg2_str;
22434   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22435   {
22436     try {
22437       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22438     } catch (std::out_of_range& e) {
22439       {
22440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22441       };
22442     } catch (std::exception& e) {
22443       {
22444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22445       };
22446     } catch (Dali::DaliException e) {
22447       {
22448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22449       };
22450     } catch (...) {
22451       {
22452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22453       };
22454     }
22455   }
22456
22457   jresult = (void *)result;
22458
22459   //argout typemap for const std::string&
22460
22461   return jresult;
22462 }
22463
22464
22465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22466   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22467
22468   arg1 = (Dali::TypeAction *)jarg1;
22469   {
22470     try {
22471       delete arg1;
22472     } catch (std::out_of_range& e) {
22473       {
22474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22475       };
22476     } catch (std::exception& e) {
22477       {
22478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22479       };
22480     } catch (Dali::DaliException e) {
22481       {
22482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22483       };
22484     } catch (...) {
22485       {
22486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22487       };
22488     }
22489   }
22490
22491 }
22492
22493
22494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22495   void * jresult ;
22496   Dali::TypeRegistration *arg1 = 0 ;
22497   std::string *arg2 = 0 ;
22498   Dali::Property::Index arg3 ;
22499   Dali::Property::Type arg4 ;
22500   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22501   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22502   Dali::PropertyRegistration *result = 0 ;
22503
22504   arg1 = (Dali::TypeRegistration *)jarg1;
22505   if (!arg1) {
22506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22507     return 0;
22508   }
22509   if (!jarg2) {
22510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22511     return 0;
22512   }
22513   std::string arg2_str(jarg2);
22514   arg2 = &arg2_str;
22515   arg3 = (Dali::Property::Index)jarg3;
22516   arg4 = (Dali::Property::Type)jarg4;
22517   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22518   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22519   {
22520     try {
22521       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22522     } catch (std::out_of_range& e) {
22523       {
22524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22525       };
22526     } catch (std::exception& e) {
22527       {
22528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22529       };
22530     } catch (Dali::DaliException e) {
22531       {
22532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22533       };
22534     } catch (...) {
22535       {
22536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22537       };
22538     }
22539   }
22540
22541   jresult = (void *)result;
22542
22543   //argout typemap for const std::string&
22544
22545   return jresult;
22546 }
22547
22548
22549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22550   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22551
22552   arg1 = (Dali::PropertyRegistration *)jarg1;
22553   {
22554     try {
22555       delete arg1;
22556     } catch (std::out_of_range& e) {
22557       {
22558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22559       };
22560     } catch (std::exception& e) {
22561       {
22562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22563       };
22564     } catch (Dali::DaliException e) {
22565       {
22566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22567       };
22568     } catch (...) {
22569       {
22570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22571       };
22572     }
22573   }
22574
22575 }
22576
22577
22578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22579   void * jresult ;
22580   Dali::TypeRegistration *arg1 = 0 ;
22581   std::string *arg2 = 0 ;
22582   Dali::Property::Index arg3 ;
22583   Dali::Property::Type arg4 ;
22584   Dali::AnimatablePropertyRegistration *result = 0 ;
22585
22586   arg1 = (Dali::TypeRegistration *)jarg1;
22587   if (!arg1) {
22588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22589     return 0;
22590   }
22591   if (!jarg2) {
22592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22593     return 0;
22594   }
22595   std::string arg2_str(jarg2);
22596   arg2 = &arg2_str;
22597   arg3 = (Dali::Property::Index)jarg3;
22598   arg4 = (Dali::Property::Type)jarg4;
22599   {
22600     try {
22601       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22602     } catch (std::out_of_range& e) {
22603       {
22604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22605       };
22606     } catch (std::exception& e) {
22607       {
22608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22609       };
22610     } catch (Dali::DaliException e) {
22611       {
22612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22613       };
22614     } catch (...) {
22615       {
22616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22617       };
22618     }
22619   }
22620
22621   jresult = (void *)result;
22622
22623   //argout typemap for const std::string&
22624
22625   return jresult;
22626 }
22627
22628
22629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22630   void * jresult ;
22631   Dali::TypeRegistration *arg1 = 0 ;
22632   std::string *arg2 = 0 ;
22633   Dali::Property::Index arg3 ;
22634   Dali::Property::Value *arg4 = 0 ;
22635   Dali::AnimatablePropertyRegistration *result = 0 ;
22636
22637   arg1 = (Dali::TypeRegistration *)jarg1;
22638   if (!arg1) {
22639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22640     return 0;
22641   }
22642   if (!jarg2) {
22643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22644     return 0;
22645   }
22646   std::string arg2_str(jarg2);
22647   arg2 = &arg2_str;
22648   arg3 = (Dali::Property::Index)jarg3;
22649   arg4 = (Dali::Property::Value *)jarg4;
22650   if (!arg4) {
22651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22652     return 0;
22653   }
22654   {
22655     try {
22656       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22657     } catch (std::out_of_range& e) {
22658       {
22659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22660       };
22661     } catch (std::exception& e) {
22662       {
22663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22664       };
22665     } catch (Dali::DaliException e) {
22666       {
22667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22668       };
22669     } catch (...) {
22670       {
22671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22672       };
22673     }
22674   }
22675
22676   jresult = (void *)result;
22677
22678   //argout typemap for const std::string&
22679
22680   return jresult;
22681 }
22682
22683
22684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22685   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22686
22687   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22688   {
22689     try {
22690       delete arg1;
22691     } catch (std::out_of_range& e) {
22692       {
22693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22694       };
22695     } catch (std::exception& e) {
22696       {
22697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22698       };
22699     } catch (Dali::DaliException e) {
22700       {
22701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22702       };
22703     } catch (...) {
22704       {
22705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22706       };
22707     }
22708   }
22709
22710 }
22711
22712
22713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22714   void * jresult ;
22715   Dali::TypeRegistration *arg1 = 0 ;
22716   std::string *arg2 = 0 ;
22717   Dali::Property::Index arg3 ;
22718   Dali::Property::Index arg4 ;
22719   unsigned int arg5 ;
22720   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22721
22722   arg1 = (Dali::TypeRegistration *)jarg1;
22723   if (!arg1) {
22724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22725     return 0;
22726   }
22727   if (!jarg2) {
22728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22729     return 0;
22730   }
22731   std::string arg2_str(jarg2);
22732   arg2 = &arg2_str;
22733   arg3 = (Dali::Property::Index)jarg3;
22734   arg4 = (Dali::Property::Index)jarg4;
22735   arg5 = (unsigned int)jarg5;
22736   {
22737     try {
22738       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22739     } catch (std::out_of_range& e) {
22740       {
22741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22742       };
22743     } catch (std::exception& e) {
22744       {
22745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22746       };
22747     } catch (Dali::DaliException e) {
22748       {
22749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22750       };
22751     } catch (...) {
22752       {
22753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22754       };
22755     }
22756   }
22757
22758   jresult = (void *)result;
22759
22760   //argout typemap for const std::string&
22761
22762   return jresult;
22763 }
22764
22765
22766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22767   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22768
22769   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22770   {
22771     try {
22772       delete arg1;
22773     } catch (std::out_of_range& e) {
22774       {
22775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22776       };
22777     } catch (std::exception& e) {
22778       {
22779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22780       };
22781     } catch (Dali::DaliException e) {
22782       {
22783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22784       };
22785     } catch (...) {
22786       {
22787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22788       };
22789     }
22790   }
22791
22792 }
22793
22794
22795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22796   void * jresult ;
22797   Dali::TypeRegistration *arg1 = 0 ;
22798   std::string *arg2 = 0 ;
22799   Dali::Property::Index arg3 ;
22800   Dali::Property::Type arg4 ;
22801   Dali::ChildPropertyRegistration *result = 0 ;
22802
22803   arg1 = (Dali::TypeRegistration *)jarg1;
22804   if (!arg1) {
22805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22806     return 0;
22807   }
22808   if (!jarg2) {
22809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22810     return 0;
22811   }
22812   std::string arg2_str(jarg2);
22813   arg2 = &arg2_str;
22814   arg3 = (Dali::Property::Index)jarg3;
22815   arg4 = (Dali::Property::Type)jarg4;
22816   {
22817     try {
22818       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22819     } catch (std::out_of_range& e) {
22820       {
22821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22822       };
22823     } catch (std::exception& e) {
22824       {
22825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22826       };
22827     } catch (Dali::DaliException e) {
22828       {
22829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22830       };
22831     } catch (...) {
22832       {
22833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22834       };
22835     }
22836   }
22837
22838   jresult = (void *)result;
22839
22840   //argout typemap for const std::string&
22841
22842   return jresult;
22843 }
22844
22845
22846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22847   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22848
22849   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22850   {
22851     try {
22852       delete arg1;
22853     } catch (std::out_of_range& e) {
22854       {
22855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22856       };
22857     } catch (std::exception& e) {
22858       {
22859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22860       };
22861     } catch (Dali::DaliException e) {
22862       {
22863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22864       };
22865     } catch (...) {
22866       {
22867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22868       };
22869     }
22870   }
22871
22872 }
22873
22874
22875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22876   unsigned int jresult ;
22877   std::string *arg1 = 0 ;
22878   std::type_info *arg2 = 0 ;
22879   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22880   bool result;
22881
22882   if (!jarg1) {
22883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22884     return 0;
22885   }
22886   std::string arg1_str(jarg1);
22887   arg1 = &arg1_str;
22888   arg2 = (std::type_info *)jarg2;
22889   if (!arg2) {
22890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22891     return 0;
22892   }
22893   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22894   {
22895     try {
22896       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22897     } catch (std::out_of_range& e) {
22898       {
22899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22900       };
22901     } catch (std::exception& e) {
22902       {
22903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22904       };
22905     } catch (Dali::DaliException e) {
22906       {
22907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22908       };
22909     } catch (...) {
22910       {
22911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22912       };
22913     }
22914   }
22915
22916   jresult = result;
22917
22918   //argout typemap for const std::string&
22919
22920   return jresult;
22921 }
22922
22923
22924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22925   unsigned int jresult ;
22926   std::string *arg1 = 0 ;
22927   std::string *arg2 = 0 ;
22928   Dali::Property::Index arg3 ;
22929   Dali::Property::Type arg4 ;
22930   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22931   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22932   bool result;
22933
22934   if (!jarg1) {
22935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22936     return 0;
22937   }
22938   std::string arg1_str(jarg1);
22939   arg1 = &arg1_str;
22940   if (!jarg2) {
22941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22942     return 0;
22943   }
22944   std::string arg2_str(jarg2);
22945   arg2 = &arg2_str;
22946   arg3 = (Dali::Property::Index)jarg3;
22947   arg4 = (Dali::Property::Type)jarg4;
22948   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22949   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22950   {
22951     try {
22952       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22953     } catch (std::out_of_range& e) {
22954       {
22955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22956       };
22957     } catch (std::exception& e) {
22958       {
22959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22960       };
22961     } catch (Dali::DaliException e) {
22962       {
22963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22964       };
22965     } catch (...) {
22966       {
22967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22968       };
22969     }
22970   }
22971
22972   jresult = result;
22973
22974   //argout typemap for const std::string&
22975
22976
22977   //argout typemap for const std::string&
22978
22979   return jresult;
22980 }
22981
22982
22983 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22984   float jresult ;
22985   float result;
22986
22987   result = (float)(float)Dali::ParentOrigin::TOP;
22988   jresult = result;
22989   return jresult;
22990 }
22991
22992
22993 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22994   float jresult ;
22995   float result;
22996
22997   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22998   jresult = result;
22999   return jresult;
23000 }
23001
23002
23003 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
23004   float jresult ;
23005   float result;
23006
23007   result = (float)(float)Dali::ParentOrigin::LEFT;
23008   jresult = result;
23009   return jresult;
23010 }
23011
23012
23013 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
23014   float jresult ;
23015   float result;
23016
23017   result = (float)(float)Dali::ParentOrigin::RIGHT;
23018   jresult = result;
23019   return jresult;
23020 }
23021
23022
23023 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
23024   float jresult ;
23025   float result;
23026
23027   result = (float)(float)Dali::ParentOrigin::MIDDLE;
23028   jresult = result;
23029   return jresult;
23030 }
23031
23032
23033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
23034   void * jresult ;
23035   Dali::Vector3 *result = 0 ;
23036
23037   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
23038   jresult = (void *)result;
23039   return jresult;
23040 }
23041
23042
23043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
23044   void * jresult ;
23045   Dali::Vector3 *result = 0 ;
23046
23047   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
23048   jresult = (void *)result;
23049   return jresult;
23050 }
23051
23052
23053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
23054   void * jresult ;
23055   Dali::Vector3 *result = 0 ;
23056
23057   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
23058   jresult = (void *)result;
23059   return jresult;
23060 }
23061
23062
23063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
23064   void * jresult ;
23065   Dali::Vector3 *result = 0 ;
23066
23067   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
23068   jresult = (void *)result;
23069   return jresult;
23070 }
23071
23072
23073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23074   void * jresult ;
23075   Dali::Vector3 *result = 0 ;
23076
23077   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23078   jresult = (void *)result;
23079   return jresult;
23080 }
23081
23082
23083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23084   void * jresult ;
23085   Dali::Vector3 *result = 0 ;
23086
23087   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23088   jresult = (void *)result;
23089   return jresult;
23090 }
23091
23092
23093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23094   void * jresult ;
23095   Dali::Vector3 *result = 0 ;
23096
23097   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23098   jresult = (void *)result;
23099   return jresult;
23100 }
23101
23102
23103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23104   void * jresult ;
23105   Dali::Vector3 *result = 0 ;
23106
23107   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23108   jresult = (void *)result;
23109   return jresult;
23110 }
23111
23112
23113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23114   void * jresult ;
23115   Dali::Vector3 *result = 0 ;
23116
23117   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23118   jresult = (void *)result;
23119   return jresult;
23120 }
23121
23122
23123 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23124   float jresult ;
23125   float result;
23126
23127   result = (float)(float)Dali::AnchorPoint::TOP;
23128   jresult = result;
23129   return jresult;
23130 }
23131
23132
23133 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23134   float jresult ;
23135   float result;
23136
23137   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23138   jresult = result;
23139   return jresult;
23140 }
23141
23142
23143 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23144   float jresult ;
23145   float result;
23146
23147   result = (float)(float)Dali::AnchorPoint::LEFT;
23148   jresult = result;
23149   return jresult;
23150 }
23151
23152
23153 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23154   float jresult ;
23155   float result;
23156
23157   result = (float)(float)Dali::AnchorPoint::RIGHT;
23158   jresult = result;
23159   return jresult;
23160 }
23161
23162
23163 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23164   float jresult ;
23165   float result;
23166
23167   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23168   jresult = result;
23169   return jresult;
23170 }
23171
23172
23173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23174   void * jresult ;
23175   Dali::Vector3 *result = 0 ;
23176
23177   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23178   jresult = (void *)result;
23179   return jresult;
23180 }
23181
23182
23183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23184   void * jresult ;
23185   Dali::Vector3 *result = 0 ;
23186
23187   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23188   jresult = (void *)result;
23189   return jresult;
23190 }
23191
23192
23193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23194   void * jresult ;
23195   Dali::Vector3 *result = 0 ;
23196
23197   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23198   jresult = (void *)result;
23199   return jresult;
23200 }
23201
23202
23203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23204   void * jresult ;
23205   Dali::Vector3 *result = 0 ;
23206
23207   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23208   jresult = (void *)result;
23209   return jresult;
23210 }
23211
23212
23213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23214   void * jresult ;
23215   Dali::Vector3 *result = 0 ;
23216
23217   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23218   jresult = (void *)result;
23219   return jresult;
23220 }
23221
23222
23223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23224   void * jresult ;
23225   Dali::Vector3 *result = 0 ;
23226
23227   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23228   jresult = (void *)result;
23229   return jresult;
23230 }
23231
23232
23233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23234   void * jresult ;
23235   Dali::Vector3 *result = 0 ;
23236
23237   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23238   jresult = (void *)result;
23239   return jresult;
23240 }
23241
23242
23243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23244   void * jresult ;
23245   Dali::Vector3 *result = 0 ;
23246
23247   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23248   jresult = (void *)result;
23249   return jresult;
23250 }
23251
23252
23253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23254   void * jresult ;
23255   Dali::Vector3 *result = 0 ;
23256
23257   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23258   jresult = (void *)result;
23259   return jresult;
23260 }
23261
23262
23263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23264   void * jresult ;
23265   Dali::Vector4 *result = 0 ;
23266
23267   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23268   jresult = (void *)result;
23269   return jresult;
23270 }
23271
23272
23273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23274   void * jresult ;
23275   Dali::Vector4 *result = 0 ;
23276
23277   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23278   jresult = (void *)result;
23279   return jresult;
23280 }
23281
23282
23283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23284   void * jresult ;
23285   Dali::Vector4 *result = 0 ;
23286
23287   result = (Dali::Vector4 *)&Dali::Color::RED;
23288   jresult = (void *)result;
23289   return jresult;
23290 }
23291
23292
23293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23294   void * jresult ;
23295   Dali::Vector4 *result = 0 ;
23296
23297   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23298   jresult = (void *)result;
23299   return jresult;
23300 }
23301
23302
23303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23304   void * jresult ;
23305   Dali::Vector4 *result = 0 ;
23306
23307   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23308   jresult = (void *)result;
23309   return jresult;
23310 }
23311
23312
23313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23314   void * jresult ;
23315   Dali::Vector4 *result = 0 ;
23316
23317   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23318   jresult = (void *)result;
23319   return jresult;
23320 }
23321
23322
23323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23324   void * jresult ;
23325   Dali::Vector4 *result = 0 ;
23326
23327   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23328   jresult = (void *)result;
23329   return jresult;
23330 }
23331
23332
23333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23334   void * jresult ;
23335   Dali::Vector4 *result = 0 ;
23336
23337   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23338   jresult = (void *)result;
23339   return jresult;
23340 }
23341
23342
23343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23344   void * jresult ;
23345   Dali::Vector4 *result = 0 ;
23346
23347   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23348   jresult = (void *)result;
23349   return jresult;
23350 }
23351
23352
23353 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23354   float jresult ;
23355   float result;
23356
23357   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23358   jresult = result;
23359   return jresult;
23360 }
23361
23362
23363 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23364   float jresult ;
23365   float result;
23366
23367   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23368   jresult = result;
23369   return jresult;
23370 }
23371
23372
23373 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23374   float jresult ;
23375   float result;
23376
23377   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23378   jresult = result;
23379   return jresult;
23380 }
23381
23382
23383 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23384   float jresult ;
23385   float result;
23386
23387   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23388   jresult = result;
23389   return jresult;
23390 }
23391
23392
23393 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23394   float jresult ;
23395   float result;
23396
23397   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23398   jresult = result;
23399   return jresult;
23400 }
23401
23402
23403 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23404   float jresult ;
23405   float result;
23406
23407   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23408   jresult = result;
23409   return jresult;
23410 }
23411
23412
23413 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23414   float jresult ;
23415   float result;
23416
23417   result = (float)(float)Dali::Math::PI;
23418   jresult = result;
23419   return jresult;
23420 }
23421
23422
23423 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23424   float jresult ;
23425   float result;
23426
23427   result = (float)(float)Dali::Math::PI_2;
23428   jresult = result;
23429   return jresult;
23430 }
23431
23432
23433 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23434   float jresult ;
23435   float result;
23436
23437   result = (float)(float)Dali::Math::PI_4;
23438   jresult = result;
23439   return jresult;
23440 }
23441
23442
23443 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23444   float jresult ;
23445   float result;
23446
23447   result = (float)(float)Dali::Math::PI_OVER_180;
23448   jresult = result;
23449   return jresult;
23450 }
23451
23452
23453 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23454   float jresult ;
23455   float result;
23456
23457   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23458   jresult = result;
23459   return jresult;
23460 }
23461
23462
23463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23464   int jresult ;
23465   Dali::ResizePolicy::Type result;
23466
23467   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23468   jresult = (int)result;
23469   return jresult;
23470 }
23471
23472
23473 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23474   unsigned long jresult ;
23475   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23476   Dali::VectorBase::SizeType result;
23477
23478   arg1 = (Dali::VectorBase *)jarg1;
23479   {
23480     try {
23481       result = ((Dali::VectorBase const *)arg1)->Count();
23482     } catch (std::out_of_range& e) {
23483       {
23484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23485       };
23486     } catch (std::exception& e) {
23487       {
23488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23489       };
23490     } catch (Dali::DaliException e) {
23491       {
23492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23493       };
23494     } catch (...) {
23495       {
23496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23497       };
23498     }
23499   }
23500
23501   jresult = (unsigned long)result;
23502   return jresult;
23503 }
23504
23505
23506 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23507   unsigned long jresult ;
23508   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23509   Dali::VectorBase::SizeType result;
23510
23511   arg1 = (Dali::VectorBase *)jarg1;
23512   {
23513     try {
23514       result = ((Dali::VectorBase const *)arg1)->Size();
23515     } catch (std::out_of_range& e) {
23516       {
23517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23518       };
23519     } catch (std::exception& e) {
23520       {
23521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23522       };
23523     } catch (Dali::DaliException e) {
23524       {
23525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23526       };
23527     } catch (...) {
23528       {
23529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23530       };
23531     }
23532   }
23533
23534   jresult = (unsigned long)result;
23535   return jresult;
23536 }
23537
23538
23539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23540   unsigned int jresult ;
23541   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23542   bool result;
23543
23544   arg1 = (Dali::VectorBase *)jarg1;
23545   {
23546     try {
23547       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23548     } catch (std::out_of_range& e) {
23549       {
23550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23551       };
23552     } catch (std::exception& e) {
23553       {
23554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23555       };
23556     } catch (Dali::DaliException e) {
23557       {
23558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23559       };
23560     } catch (...) {
23561       {
23562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23563       };
23564     }
23565   }
23566
23567   jresult = result;
23568   return jresult;
23569 }
23570
23571
23572 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23573   unsigned long jresult ;
23574   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23575   Dali::VectorBase::SizeType result;
23576
23577   arg1 = (Dali::VectorBase *)jarg1;
23578   {
23579     try {
23580       result = ((Dali::VectorBase const *)arg1)->Capacity();
23581     } catch (std::out_of_range& e) {
23582       {
23583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23584       };
23585     } catch (std::exception& e) {
23586       {
23587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23588       };
23589     } catch (Dali::DaliException e) {
23590       {
23591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23592       };
23593     } catch (...) {
23594       {
23595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23596       };
23597     }
23598   }
23599
23600   jresult = (unsigned long)result;
23601   return jresult;
23602 }
23603
23604
23605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23606   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23607
23608   arg1 = (Dali::VectorBase *)jarg1;
23609   {
23610     try {
23611       (arg1)->Release();
23612     } catch (std::out_of_range& e) {
23613       {
23614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23615       };
23616     } catch (std::exception& e) {
23617       {
23618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23619       };
23620     } catch (Dali::DaliException e) {
23621       {
23622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23623       };
23624     } catch (...) {
23625       {
23626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23627       };
23628     }
23629   }
23630
23631 }
23632
23633
23634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23635   void * jresult ;
23636   Dali::Image *result = 0 ;
23637
23638   {
23639     try {
23640       result = (Dali::Image *)new Dali::Image();
23641     } catch (std::out_of_range& e) {
23642       {
23643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23644       };
23645     } catch (std::exception& e) {
23646       {
23647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23648       };
23649     } catch (Dali::DaliException e) {
23650       {
23651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23652       };
23653     } catch (...) {
23654       {
23655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23656       };
23657     }
23658   }
23659
23660   jresult = (void *)result;
23661   return jresult;
23662 }
23663
23664
23665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23666   Dali::Image *arg1 = (Dali::Image *) 0 ;
23667
23668   arg1 = (Dali::Image *)jarg1;
23669   {
23670     try {
23671       delete arg1;
23672     } catch (std::out_of_range& e) {
23673       {
23674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23675       };
23676     } catch (std::exception& e) {
23677       {
23678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23679       };
23680     } catch (Dali::DaliException e) {
23681       {
23682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23683       };
23684     } catch (...) {
23685       {
23686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23687       };
23688     }
23689   }
23690
23691 }
23692
23693
23694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23695   void * jresult ;
23696   Dali::Image *arg1 = 0 ;
23697   Dali::Image *result = 0 ;
23698
23699   arg1 = (Dali::Image *)jarg1;
23700   if (!arg1) {
23701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23702     return 0;
23703   }
23704   {
23705     try {
23706       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23707     } catch (std::out_of_range& e) {
23708       {
23709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23710       };
23711     } catch (std::exception& e) {
23712       {
23713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23714       };
23715     } catch (Dali::DaliException e) {
23716       {
23717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23718       };
23719     } catch (...) {
23720       {
23721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23722       };
23723     }
23724   }
23725
23726   jresult = (void *)result;
23727   return jresult;
23728 }
23729
23730
23731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23732   void * jresult ;
23733   Dali::Image *arg1 = (Dali::Image *) 0 ;
23734   Dali::Image *arg2 = 0 ;
23735   Dali::Image *result = 0 ;
23736
23737   arg1 = (Dali::Image *)jarg1;
23738   arg2 = (Dali::Image *)jarg2;
23739   if (!arg2) {
23740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23741     return 0;
23742   }
23743   {
23744     try {
23745       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
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 = (void *)result;
23766   return jresult;
23767 }
23768
23769
23770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23771   void * jresult ;
23772   Dali::BaseHandle arg1 ;
23773   Dali::BaseHandle *argp1 ;
23774   Dali::Image result;
23775
23776   argp1 = (Dali::BaseHandle *)jarg1;
23777   if (!argp1) {
23778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23779     return 0;
23780   }
23781   arg1 = *argp1;
23782   {
23783     try {
23784       result = Dali::Image::DownCast(arg1);
23785     } catch (std::out_of_range& e) {
23786       {
23787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23788       };
23789     } catch (std::exception& e) {
23790       {
23791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23792       };
23793     } catch (Dali::DaliException e) {
23794       {
23795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23796       };
23797     } catch (...) {
23798       {
23799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23800       };
23801     }
23802   }
23803
23804   jresult = new Dali::Image((const Dali::Image &)result);
23805   return jresult;
23806 }
23807
23808
23809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23810   unsigned int jresult ;
23811   Dali::Image *arg1 = (Dali::Image *) 0 ;
23812   unsigned int result;
23813
23814   arg1 = (Dali::Image *)jarg1;
23815   {
23816     try {
23817       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23818     } catch (std::out_of_range& e) {
23819       {
23820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23821       };
23822     } catch (std::exception& e) {
23823       {
23824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23825       };
23826     } catch (Dali::DaliException e) {
23827       {
23828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23829       };
23830     } catch (...) {
23831       {
23832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23833       };
23834     }
23835   }
23836
23837   jresult = result;
23838   return jresult;
23839 }
23840
23841
23842 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23843   unsigned int jresult ;
23844   Dali::Image *arg1 = (Dali::Image *) 0 ;
23845   unsigned int result;
23846
23847   arg1 = (Dali::Image *)jarg1;
23848   {
23849     try {
23850       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23851     } catch (std::out_of_range& e) {
23852       {
23853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23854       };
23855     } catch (std::exception& e) {
23856       {
23857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23858       };
23859     } catch (Dali::DaliException e) {
23860       {
23861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23862       };
23863     } catch (...) {
23864       {
23865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23866       };
23867     }
23868   }
23869
23870   jresult = result;
23871   return jresult;
23872 }
23873
23874
23875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23876   void * jresult ;
23877   Dali::Image *arg1 = (Dali::Image *) 0 ;
23878   Dali::Image::ImageSignalType *result = 0 ;
23879
23880   arg1 = (Dali::Image *)jarg1;
23881   {
23882     try {
23883       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23884     } catch (std::out_of_range& e) {
23885       {
23886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23887       };
23888     } catch (std::exception& e) {
23889       {
23890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23891       };
23892     } catch (Dali::DaliException e) {
23893       {
23894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23895       };
23896     } catch (...) {
23897       {
23898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23899       };
23900     }
23901   }
23902
23903   jresult = (void *)result;
23904   return jresult;
23905 }
23906
23907
23908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23909   int jresult ;
23910   Dali::Pixel::Format result;
23911
23912   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23913   jresult = (int)result;
23914   return jresult;
23915 }
23916
23917
23918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23919   int jresult ;
23920   Dali::Pixel::Format result;
23921
23922   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23923   jresult = (int)result;
23924   return jresult;
23925 }
23926
23927
23928 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23929   unsigned int jresult ;
23930   Dali::Pixel::Format arg1 ;
23931   bool result;
23932
23933   arg1 = (Dali::Pixel::Format)jarg1;
23934   {
23935     try {
23936       result = (bool)Dali::Pixel::HasAlpha(arg1);
23937     } catch (std::out_of_range& e) {
23938       {
23939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23940       };
23941     } catch (std::exception& e) {
23942       {
23943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23944       };
23945     } catch (Dali::DaliException e) {
23946       {
23947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23948       };
23949     } catch (...) {
23950       {
23951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23952       };
23953     }
23954   }
23955
23956   jresult = result;
23957   return jresult;
23958 }
23959
23960
23961 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23962   unsigned int jresult ;
23963   Dali::Pixel::Format arg1 ;
23964   unsigned int result;
23965
23966   arg1 = (Dali::Pixel::Format)jarg1;
23967   {
23968     try {
23969       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23970     } catch (std::out_of_range& e) {
23971       {
23972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23973       };
23974     } catch (std::exception& e) {
23975       {
23976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23977       };
23978     } catch (Dali::DaliException e) {
23979       {
23980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23981       };
23982     } catch (...) {
23983       {
23984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23985       };
23986     }
23987   }
23988
23989   jresult = result;
23990   return jresult;
23991 }
23992
23993
23994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23995   Dali::Pixel::Format arg1 ;
23996   int *arg2 = 0 ;
23997   int *arg3 = 0 ;
23998
23999   arg1 = (Dali::Pixel::Format)jarg1;
24000   arg2 = (int *)jarg2;
24001   if (!arg2) {
24002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
24003     return ;
24004   }
24005   arg3 = (int *)jarg3;
24006   if (!arg3) {
24007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
24008     return ;
24009   }
24010   {
24011     try {
24012       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
24013     } catch (std::out_of_range& e) {
24014       {
24015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24016       };
24017     } catch (std::exception& e) {
24018       {
24019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24020       };
24021     } catch (Dali::DaliException e) {
24022       {
24023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24024       };
24025     } catch (...) {
24026       {
24027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24028       };
24029     }
24030   }
24031
24032 }
24033
24034
24035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
24036   void * jresult ;
24037   unsigned char *arg1 = (unsigned char *) 0 ;
24038   unsigned int arg2 ;
24039   unsigned int arg3 ;
24040   unsigned int arg4 ;
24041   Dali::Pixel::Format arg5 ;
24042   Dali::PixelData::ReleaseFunction arg6 ;
24043   Dali::PixelData result;
24044
24045   arg1 = jarg1;
24046   arg2 = (unsigned int)jarg2;
24047   arg3 = (unsigned int)jarg3;
24048   arg4 = (unsigned int)jarg4;
24049   arg5 = (Dali::Pixel::Format)jarg5;
24050   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
24051   {
24052     try {
24053       auto pixelBuffer = new unsigned char[jarg2];
24054       memcpy( pixelBuffer, arg1, arg2);
24055       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
24056     } catch (std::out_of_range& e) {
24057       {
24058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24059       };
24060     } catch (std::exception& e) {
24061       {
24062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24063       };
24064     } catch (Dali::DaliException e) {
24065       {
24066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24067       };
24068     } catch (...) {
24069       {
24070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24071       };
24072     }
24073   }
24074
24075   jresult = new Dali::PixelData((const Dali::PixelData &)result);
24076
24077
24078   return jresult;
24079 }
24080
24081
24082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24083   void * jresult ;
24084   Dali::PixelData *result = 0 ;
24085
24086   {
24087     try {
24088       result = (Dali::PixelData *)new Dali::PixelData();
24089     } catch (std::out_of_range& e) {
24090       {
24091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24092       };
24093     } catch (std::exception& e) {
24094       {
24095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24096       };
24097     } catch (Dali::DaliException e) {
24098       {
24099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24100       };
24101     } catch (...) {
24102       {
24103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24104       };
24105     }
24106   }
24107
24108   jresult = (void *)result;
24109   return jresult;
24110 }
24111
24112
24113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24114   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24115
24116   arg1 = (Dali::PixelData *)jarg1;
24117   {
24118     try {
24119       delete arg1;
24120     } catch (std::out_of_range& e) {
24121       {
24122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24123       };
24124     } catch (std::exception& e) {
24125       {
24126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24127       };
24128     } catch (Dali::DaliException e) {
24129       {
24130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24131       };
24132     } catch (...) {
24133       {
24134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24135       };
24136     }
24137   }
24138
24139 }
24140
24141
24142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24143   void * jresult ;
24144   Dali::PixelData *arg1 = 0 ;
24145   Dali::PixelData *result = 0 ;
24146
24147   arg1 = (Dali::PixelData *)jarg1;
24148   if (!arg1) {
24149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24150     return 0;
24151   }
24152   {
24153     try {
24154       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
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 = (void *)result;
24175   return jresult;
24176 }
24177
24178
24179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24180   void * jresult ;
24181   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24182   Dali::PixelData *arg2 = 0 ;
24183   Dali::PixelData *result = 0 ;
24184
24185   arg1 = (Dali::PixelData *)jarg1;
24186   arg2 = (Dali::PixelData *)jarg2;
24187   if (!arg2) {
24188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24189     return 0;
24190   }
24191   {
24192     try {
24193       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24194     } catch (std::out_of_range& e) {
24195       {
24196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24197       };
24198     } catch (std::exception& e) {
24199       {
24200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24201       };
24202     } catch (Dali::DaliException e) {
24203       {
24204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24205       };
24206     } catch (...) {
24207       {
24208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24209       };
24210     }
24211   }
24212
24213   jresult = (void *)result;
24214   return jresult;
24215 }
24216
24217
24218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24219   unsigned int jresult ;
24220   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24221   unsigned int result;
24222
24223   arg1 = (Dali::PixelData *)jarg1;
24224   {
24225     try {
24226       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24227     } catch (std::out_of_range& e) {
24228       {
24229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24230       };
24231     } catch (std::exception& e) {
24232       {
24233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24234       };
24235     } catch (Dali::DaliException e) {
24236       {
24237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24238       };
24239     } catch (...) {
24240       {
24241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24242       };
24243     }
24244   }
24245
24246   jresult = result;
24247   return jresult;
24248 }
24249
24250
24251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24252   unsigned int jresult ;
24253   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24254   unsigned int result;
24255
24256   arg1 = (Dali::PixelData *)jarg1;
24257   {
24258     try {
24259       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24260     } catch (std::out_of_range& e) {
24261       {
24262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24263       };
24264     } catch (std::exception& e) {
24265       {
24266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24267       };
24268     } catch (Dali::DaliException e) {
24269       {
24270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24271       };
24272     } catch (...) {
24273       {
24274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24275       };
24276     }
24277   }
24278
24279   jresult = result;
24280   return jresult;
24281 }
24282
24283
24284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24285   int jresult ;
24286   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24287   Dali::Pixel::Format result;
24288
24289   arg1 = (Dali::PixelData *)jarg1;
24290   {
24291     try {
24292       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24293     } catch (std::out_of_range& e) {
24294       {
24295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24296       };
24297     } catch (std::exception& e) {
24298       {
24299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24300       };
24301     } catch (Dali::DaliException e) {
24302       {
24303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24304       };
24305     } catch (...) {
24306       {
24307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24308       };
24309     }
24310   }
24311
24312   jresult = (int)result;
24313   return jresult;
24314 }
24315
24316
24317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24318   unsigned int jresult ;
24319   unsigned int result;
24320
24321   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24322   jresult = result;
24323   return jresult;
24324 }
24325
24326
24327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24328   unsigned int jresult ;
24329   unsigned int result;
24330
24331   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24332   jresult = result;
24333   return jresult;
24334 }
24335
24336
24337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24338   unsigned int jresult ;
24339   unsigned int result;
24340
24341   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24342   jresult = result;
24343   return jresult;
24344 }
24345
24346
24347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24348   unsigned int jresult ;
24349   unsigned int result;
24350
24351   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24352   jresult = result;
24353   return jresult;
24354 }
24355
24356
24357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24358   unsigned int jresult ;
24359   unsigned int result;
24360
24361   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24362   jresult = result;
24363   return jresult;
24364 }
24365
24366
24367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24368   unsigned int jresult ;
24369   unsigned int result;
24370
24371   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24372   jresult = result;
24373   return jresult;
24374 }
24375
24376
24377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24378   void * jresult ;
24379   Dali::TextureType::Type arg1 ;
24380   Dali::Pixel::Format arg2 ;
24381   unsigned int arg3 ;
24382   unsigned int arg4 ;
24383   Dali::Texture result;
24384
24385   arg1 = (Dali::TextureType::Type)jarg1;
24386   arg2 = (Dali::Pixel::Format)jarg2;
24387   arg3 = (unsigned int)jarg3;
24388   arg4 = (unsigned int)jarg4;
24389   {
24390     try {
24391       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24392     } catch (std::out_of_range& e) {
24393       {
24394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24395       };
24396     } catch (std::exception& e) {
24397       {
24398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24399       };
24400     } catch (Dali::DaliException e) {
24401       {
24402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24403       };
24404     } catch (...) {
24405       {
24406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24407       };
24408     }
24409   }
24410
24411   jresult = new Dali::Texture((const Dali::Texture &)result);
24412   return jresult;
24413 }
24414
24415
24416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24417   void * jresult ;
24418   NativeImageInterface *arg1 = 0 ;
24419   Dali::Texture result;
24420
24421   arg1 = (NativeImageInterface *)jarg1;
24422   if (!arg1) {
24423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24424     return 0;
24425   }
24426   {
24427     try {
24428       result = Dali::Texture::New(*arg1);
24429     } catch (std::out_of_range& e) {
24430       {
24431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24432       };
24433     } catch (std::exception& e) {
24434       {
24435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24436       };
24437     } catch (Dali::DaliException e) {
24438       {
24439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24440       };
24441     } catch (...) {
24442       {
24443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24444       };
24445     }
24446   }
24447
24448   jresult = new Dali::Texture((const Dali::Texture &)result);
24449   return jresult;
24450 }
24451
24452
24453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24454   void * jresult ;
24455   Dali::Texture *result = 0 ;
24456
24457   {
24458     try {
24459       result = (Dali::Texture *)new Dali::Texture();
24460     } catch (std::out_of_range& e) {
24461       {
24462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24463       };
24464     } catch (std::exception& e) {
24465       {
24466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24467       };
24468     } catch (Dali::DaliException e) {
24469       {
24470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24471       };
24472     } catch (...) {
24473       {
24474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24475       };
24476     }
24477   }
24478
24479   jresult = (void *)result;
24480   return jresult;
24481 }
24482
24483
24484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24485   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24486
24487   arg1 = (Dali::Texture *)jarg1;
24488   {
24489     try {
24490       delete arg1;
24491     } catch (std::out_of_range& e) {
24492       {
24493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24494       };
24495     } catch (std::exception& e) {
24496       {
24497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24498       };
24499     } catch (Dali::DaliException e) {
24500       {
24501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24502       };
24503     } catch (...) {
24504       {
24505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24506       };
24507     }
24508   }
24509
24510 }
24511
24512
24513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24514   void * jresult ;
24515   Dali::Texture *arg1 = 0 ;
24516   Dali::Texture *result = 0 ;
24517
24518   arg1 = (Dali::Texture *)jarg1;
24519   if (!arg1) {
24520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24521     return 0;
24522   }
24523   {
24524     try {
24525       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24526     } catch (std::out_of_range& e) {
24527       {
24528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24529       };
24530     } catch (std::exception& e) {
24531       {
24532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24533       };
24534     } catch (Dali::DaliException e) {
24535       {
24536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24537       };
24538     } catch (...) {
24539       {
24540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24541       };
24542     }
24543   }
24544
24545   jresult = (void *)result;
24546   return jresult;
24547 }
24548
24549
24550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24551   void * jresult ;
24552   Dali::BaseHandle arg1 ;
24553   Dali::BaseHandle *argp1 ;
24554   Dali::Texture result;
24555
24556   argp1 = (Dali::BaseHandle *)jarg1;
24557   if (!argp1) {
24558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24559     return 0;
24560   }
24561   arg1 = *argp1;
24562   {
24563     try {
24564       result = Dali::Texture::DownCast(arg1);
24565     } catch (std::out_of_range& e) {
24566       {
24567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24568       };
24569     } catch (std::exception& e) {
24570       {
24571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24572       };
24573     } catch (Dali::DaliException e) {
24574       {
24575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24576       };
24577     } catch (...) {
24578       {
24579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24580       };
24581     }
24582   }
24583
24584   jresult = new Dali::Texture((const Dali::Texture &)result);
24585   return jresult;
24586 }
24587
24588
24589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24590   void * jresult ;
24591   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24592   Dali::Texture *arg2 = 0 ;
24593   Dali::Texture *result = 0 ;
24594
24595   arg1 = (Dali::Texture *)jarg1;
24596   arg2 = (Dali::Texture *)jarg2;
24597   if (!arg2) {
24598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24599     return 0;
24600   }
24601   {
24602     try {
24603       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24604     } catch (std::out_of_range& e) {
24605       {
24606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24607       };
24608     } catch (std::exception& e) {
24609       {
24610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24611       };
24612     } catch (Dali::DaliException e) {
24613       {
24614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24615       };
24616     } catch (...) {
24617       {
24618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24619       };
24620     }
24621   }
24622
24623   jresult = (void *)result;
24624   return jresult;
24625 }
24626
24627
24628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24629   unsigned int jresult ;
24630   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24631   Dali::PixelData arg2 ;
24632   Dali::PixelData *argp2 ;
24633   bool result;
24634
24635   arg1 = (Dali::Texture *)jarg1;
24636   argp2 = (Dali::PixelData *)jarg2;
24637   if (!argp2) {
24638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24639     return 0;
24640   }
24641   arg2 = *argp2;
24642   {
24643     try {
24644       result = (bool)(arg1)->Upload(arg2);
24645     } catch (std::out_of_range& e) {
24646       {
24647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24648       };
24649     } catch (std::exception& e) {
24650       {
24651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24652       };
24653     } catch (Dali::DaliException e) {
24654       {
24655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24656       };
24657     } catch (...) {
24658       {
24659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24660       };
24661     }
24662   }
24663
24664   jresult = result;
24665   return jresult;
24666 }
24667
24668
24669 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) {
24670   unsigned int jresult ;
24671   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24672   Dali::PixelData arg2 ;
24673   unsigned int arg3 ;
24674   unsigned int arg4 ;
24675   unsigned int arg5 ;
24676   unsigned int arg6 ;
24677   unsigned int arg7 ;
24678   unsigned int arg8 ;
24679   Dali::PixelData *argp2 ;
24680   bool result;
24681
24682   arg1 = (Dali::Texture *)jarg1;
24683   argp2 = (Dali::PixelData *)jarg2;
24684   if (!argp2) {
24685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24686     return 0;
24687   }
24688   arg2 = *argp2;
24689   arg3 = (unsigned int)jarg3;
24690   arg4 = (unsigned int)jarg4;
24691   arg5 = (unsigned int)jarg5;
24692   arg6 = (unsigned int)jarg6;
24693   arg7 = (unsigned int)jarg7;
24694   arg8 = (unsigned int)jarg8;
24695   {
24696     try {
24697       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24698     } catch (std::out_of_range& e) {
24699       {
24700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24701       };
24702     } catch (std::exception& e) {
24703       {
24704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24705       };
24706     } catch (Dali::DaliException e) {
24707       {
24708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24709       };
24710     } catch (...) {
24711       {
24712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24713       };
24714     }
24715   }
24716
24717   jresult = result;
24718   return jresult;
24719 }
24720
24721
24722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24723   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24724
24725   arg1 = (Dali::Texture *)jarg1;
24726   {
24727     try {
24728       (arg1)->GenerateMipmaps();
24729     } catch (std::out_of_range& e) {
24730       {
24731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24732       };
24733     } catch (std::exception& e) {
24734       {
24735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24736       };
24737     } catch (Dali::DaliException e) {
24738       {
24739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24740       };
24741     } catch (...) {
24742       {
24743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24744       };
24745     }
24746   }
24747
24748 }
24749
24750
24751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24752   unsigned int jresult ;
24753   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24754   unsigned int result;
24755
24756   arg1 = (Dali::Texture *)jarg1;
24757   {
24758     try {
24759       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24760     } catch (std::out_of_range& e) {
24761       {
24762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24763       };
24764     } catch (std::exception& e) {
24765       {
24766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24767       };
24768     } catch (Dali::DaliException e) {
24769       {
24770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24771       };
24772     } catch (...) {
24773       {
24774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24775       };
24776     }
24777   }
24778
24779   jresult = result;
24780   return jresult;
24781 }
24782
24783
24784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24785   unsigned int jresult ;
24786   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24787   unsigned int result;
24788
24789   arg1 = (Dali::Texture *)jarg1;
24790   {
24791     try {
24792       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24793     } catch (std::out_of_range& e) {
24794       {
24795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24796       };
24797     } catch (std::exception& e) {
24798       {
24799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24800       };
24801     } catch (Dali::DaliException e) {
24802       {
24803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24804       };
24805     } catch (...) {
24806       {
24807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24808       };
24809     }
24810   }
24811
24812   jresult = result;
24813   return jresult;
24814 }
24815
24816
24817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24818   void * jresult ;
24819   Dali::Sampler result;
24820
24821   {
24822     try {
24823       result = Dali::Sampler::New();
24824     } catch (std::out_of_range& e) {
24825       {
24826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24827       };
24828     } catch (std::exception& e) {
24829       {
24830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24831       };
24832     } catch (Dali::DaliException e) {
24833       {
24834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24835       };
24836     } catch (...) {
24837       {
24838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24839       };
24840     }
24841   }
24842
24843   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24844   return jresult;
24845 }
24846
24847
24848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24849   void * jresult ;
24850   Dali::Sampler *result = 0 ;
24851
24852   {
24853     try {
24854       result = (Dali::Sampler *)new Dali::Sampler();
24855     } catch (std::out_of_range& e) {
24856       {
24857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24858       };
24859     } catch (std::exception& e) {
24860       {
24861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24862       };
24863     } catch (Dali::DaliException e) {
24864       {
24865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24866       };
24867     } catch (...) {
24868       {
24869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24870       };
24871     }
24872   }
24873
24874   jresult = (void *)result;
24875   return jresult;
24876 }
24877
24878
24879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24880   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24881
24882   arg1 = (Dali::Sampler *)jarg1;
24883   {
24884     try {
24885       delete arg1;
24886     } catch (std::out_of_range& e) {
24887       {
24888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24889       };
24890     } catch (std::exception& e) {
24891       {
24892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24893       };
24894     } catch (Dali::DaliException e) {
24895       {
24896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24897       };
24898     } catch (...) {
24899       {
24900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24901       };
24902     }
24903   }
24904
24905 }
24906
24907
24908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24909   void * jresult ;
24910   Dali::Sampler *arg1 = 0 ;
24911   Dali::Sampler *result = 0 ;
24912
24913   arg1 = (Dali::Sampler *)jarg1;
24914   if (!arg1) {
24915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24916     return 0;
24917   }
24918   {
24919     try {
24920       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24921     } catch (std::out_of_range& e) {
24922       {
24923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24924       };
24925     } catch (std::exception& e) {
24926       {
24927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24928       };
24929     } catch (Dali::DaliException e) {
24930       {
24931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24932       };
24933     } catch (...) {
24934       {
24935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24936       };
24937     }
24938   }
24939
24940   jresult = (void *)result;
24941   return jresult;
24942 }
24943
24944
24945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24946   void * jresult ;
24947   Dali::BaseHandle arg1 ;
24948   Dali::BaseHandle *argp1 ;
24949   Dali::Sampler result;
24950
24951   argp1 = (Dali::BaseHandle *)jarg1;
24952   if (!argp1) {
24953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24954     return 0;
24955   }
24956   arg1 = *argp1;
24957   {
24958     try {
24959       result = Dali::Sampler::DownCast(arg1);
24960     } catch (std::out_of_range& e) {
24961       {
24962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24963       };
24964     } catch (std::exception& e) {
24965       {
24966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24967       };
24968     } catch (Dali::DaliException e) {
24969       {
24970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24971       };
24972     } catch (...) {
24973       {
24974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24975       };
24976     }
24977   }
24978
24979   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24980   return jresult;
24981 }
24982
24983
24984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24985   void * jresult ;
24986   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24987   Dali::Sampler *arg2 = 0 ;
24988   Dali::Sampler *result = 0 ;
24989
24990   arg1 = (Dali::Sampler *)jarg1;
24991   arg2 = (Dali::Sampler *)jarg2;
24992   if (!arg2) {
24993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24994     return 0;
24995   }
24996   {
24997     try {
24998       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24999     } catch (std::out_of_range& e) {
25000       {
25001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25002       };
25003     } catch (std::exception& e) {
25004       {
25005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25006       };
25007     } catch (Dali::DaliException e) {
25008       {
25009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25010       };
25011     } catch (...) {
25012       {
25013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25014       };
25015     }
25016   }
25017
25018   jresult = (void *)result;
25019   return jresult;
25020 }
25021
25022
25023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
25024   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25025   Dali::FilterMode::Type arg2 ;
25026   Dali::FilterMode::Type arg3 ;
25027
25028   arg1 = (Dali::Sampler *)jarg1;
25029   arg2 = (Dali::FilterMode::Type)jarg2;
25030   arg3 = (Dali::FilterMode::Type)jarg3;
25031   {
25032     try {
25033       (arg1)->SetFilterMode(arg2,arg3);
25034     } catch (std::out_of_range& e) {
25035       {
25036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25037       };
25038     } catch (std::exception& e) {
25039       {
25040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25041       };
25042     } catch (Dali::DaliException e) {
25043       {
25044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25045       };
25046     } catch (...) {
25047       {
25048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25049       };
25050     }
25051   }
25052
25053 }
25054
25055
25056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
25057   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25058   Dali::WrapMode::Type arg2 ;
25059   Dali::WrapMode::Type arg3 ;
25060
25061   arg1 = (Dali::Sampler *)jarg1;
25062   arg2 = (Dali::WrapMode::Type)jarg2;
25063   arg3 = (Dali::WrapMode::Type)jarg3;
25064   {
25065     try {
25066       (arg1)->SetWrapMode(arg2,arg3);
25067     } catch (std::out_of_range& e) {
25068       {
25069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25070       };
25071     } catch (std::exception& e) {
25072       {
25073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25074       };
25075     } catch (Dali::DaliException e) {
25076       {
25077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25078       };
25079     } catch (...) {
25080       {
25081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25082       };
25083     }
25084   }
25085
25086 }
25087
25088
25089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25090   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25091   Dali::WrapMode::Type arg2 ;
25092   Dali::WrapMode::Type arg3 ;
25093   Dali::WrapMode::Type arg4 ;
25094
25095   arg1 = (Dali::Sampler *)jarg1;
25096   arg2 = (Dali::WrapMode::Type)jarg2;
25097   arg3 = (Dali::WrapMode::Type)jarg3;
25098   arg4 = (Dali::WrapMode::Type)jarg4;
25099   {
25100     try {
25101       (arg1)->SetWrapMode(arg2,arg3,arg4);
25102     } catch (std::out_of_range& e) {
25103       {
25104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25105       };
25106     } catch (std::exception& e) {
25107       {
25108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25109       };
25110     } catch (Dali::DaliException e) {
25111       {
25112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25113       };
25114     } catch (...) {
25115       {
25116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25117       };
25118     }
25119   }
25120
25121 }
25122
25123
25124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25125   void * jresult ;
25126   Dali::TextureSet result;
25127
25128   {
25129     try {
25130       result = Dali::TextureSet::New();
25131     } catch (std::out_of_range& e) {
25132       {
25133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25134       };
25135     } catch (std::exception& e) {
25136       {
25137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25138       };
25139     } catch (Dali::DaliException e) {
25140       {
25141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25142       };
25143     } catch (...) {
25144       {
25145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25146       };
25147     }
25148   }
25149
25150   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25151   return jresult;
25152 }
25153
25154
25155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25156   void * jresult ;
25157   Dali::TextureSet *result = 0 ;
25158
25159   {
25160     try {
25161       result = (Dali::TextureSet *)new Dali::TextureSet();
25162     } catch (std::out_of_range& e) {
25163       {
25164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25165       };
25166     } catch (std::exception& e) {
25167       {
25168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25169       };
25170     } catch (Dali::DaliException e) {
25171       {
25172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25173       };
25174     } catch (...) {
25175       {
25176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25177       };
25178     }
25179   }
25180
25181   jresult = (void *)result;
25182   return jresult;
25183 }
25184
25185
25186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25187   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25188
25189   arg1 = (Dali::TextureSet *)jarg1;
25190   {
25191     try {
25192       delete arg1;
25193     } catch (std::out_of_range& e) {
25194       {
25195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25196       };
25197     } catch (std::exception& e) {
25198       {
25199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25200       };
25201     } catch (Dali::DaliException e) {
25202       {
25203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25204       };
25205     } catch (...) {
25206       {
25207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25208       };
25209     }
25210   }
25211
25212 }
25213
25214
25215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25216   void * jresult ;
25217   Dali::TextureSet *arg1 = 0 ;
25218   Dali::TextureSet *result = 0 ;
25219
25220   arg1 = (Dali::TextureSet *)jarg1;
25221   if (!arg1) {
25222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25223     return 0;
25224   }
25225   {
25226     try {
25227       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25228     } catch (std::out_of_range& e) {
25229       {
25230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25231       };
25232     } catch (std::exception& e) {
25233       {
25234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25235       };
25236     } catch (Dali::DaliException e) {
25237       {
25238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25239       };
25240     } catch (...) {
25241       {
25242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25243       };
25244     }
25245   }
25246
25247   jresult = (void *)result;
25248   return jresult;
25249 }
25250
25251
25252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25253   void * jresult ;
25254   Dali::BaseHandle arg1 ;
25255   Dali::BaseHandle *argp1 ;
25256   Dali::TextureSet result;
25257
25258   argp1 = (Dali::BaseHandle *)jarg1;
25259   if (!argp1) {
25260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25261     return 0;
25262   }
25263   arg1 = *argp1;
25264   {
25265     try {
25266       result = Dali::TextureSet::DownCast(arg1);
25267     } catch (std::out_of_range& e) {
25268       {
25269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25270       };
25271     } catch (std::exception& e) {
25272       {
25273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25274       };
25275     } catch (Dali::DaliException e) {
25276       {
25277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25278       };
25279     } catch (...) {
25280       {
25281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25282       };
25283     }
25284   }
25285
25286   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25287   return jresult;
25288 }
25289
25290
25291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25292   void * jresult ;
25293   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25294   Dali::TextureSet *arg2 = 0 ;
25295   Dali::TextureSet *result = 0 ;
25296
25297   arg1 = (Dali::TextureSet *)jarg1;
25298   arg2 = (Dali::TextureSet *)jarg2;
25299   if (!arg2) {
25300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25301     return 0;
25302   }
25303   {
25304     try {
25305       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25306     } catch (std::out_of_range& e) {
25307       {
25308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25309       };
25310     } catch (std::exception& e) {
25311       {
25312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25313       };
25314     } catch (Dali::DaliException e) {
25315       {
25316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25317       };
25318     } catch (...) {
25319       {
25320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25321       };
25322     }
25323   }
25324
25325   jresult = (void *)result;
25326   return jresult;
25327 }
25328
25329
25330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25331   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25332   size_t arg2 ;
25333   Dali::Texture arg3 ;
25334   Dali::Texture *argp3 ;
25335
25336   arg1 = (Dali::TextureSet *)jarg1;
25337   arg2 = (size_t)jarg2;
25338   argp3 = (Dali::Texture *)jarg3;
25339   if (!argp3) {
25340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25341     return ;
25342   }
25343   arg3 = *argp3;
25344   {
25345     try {
25346       (arg1)->SetTexture(arg2,arg3);
25347     } catch (std::out_of_range& e) {
25348       {
25349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25350       };
25351     } catch (std::exception& e) {
25352       {
25353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25354       };
25355     } catch (Dali::DaliException e) {
25356       {
25357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25358       };
25359     } catch (...) {
25360       {
25361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25362       };
25363     }
25364   }
25365
25366 }
25367
25368
25369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25370   void * jresult ;
25371   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25372   size_t arg2 ;
25373   Dali::Texture result;
25374
25375   arg1 = (Dali::TextureSet *)jarg1;
25376   arg2 = (size_t)jarg2;
25377   {
25378     try {
25379       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25380     } catch (std::out_of_range& e) {
25381       {
25382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25383       };
25384     } catch (std::exception& e) {
25385       {
25386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25387       };
25388     } catch (Dali::DaliException e) {
25389       {
25390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25391       };
25392     } catch (...) {
25393       {
25394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25395       };
25396     }
25397   }
25398
25399   jresult = new Dali::Texture((const Dali::Texture &)result);
25400   return jresult;
25401 }
25402
25403
25404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25405   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25406   size_t arg2 ;
25407   Dali::Sampler arg3 ;
25408   Dali::Sampler *argp3 ;
25409
25410   arg1 = (Dali::TextureSet *)jarg1;
25411   arg2 = (size_t)jarg2;
25412   argp3 = (Dali::Sampler *)jarg3;
25413   if (!argp3) {
25414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25415     return ;
25416   }
25417   arg3 = *argp3;
25418   {
25419     try {
25420       (arg1)->SetSampler(arg2,arg3);
25421     } catch (std::out_of_range& e) {
25422       {
25423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25424       };
25425     } catch (std::exception& e) {
25426       {
25427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25428       };
25429     } catch (Dali::DaliException e) {
25430       {
25431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25432       };
25433     } catch (...) {
25434       {
25435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25436       };
25437     }
25438   }
25439
25440 }
25441
25442
25443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25444   void * jresult ;
25445   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25446   size_t arg2 ;
25447   Dali::Sampler result;
25448
25449   arg1 = (Dali::TextureSet *)jarg1;
25450   arg2 = (size_t)jarg2;
25451   {
25452     try {
25453       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25454     } catch (std::out_of_range& e) {
25455       {
25456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25457       };
25458     } catch (std::exception& e) {
25459       {
25460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25461       };
25462     } catch (Dali::DaliException e) {
25463       {
25464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25465       };
25466     } catch (...) {
25467       {
25468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25469       };
25470     }
25471   }
25472
25473   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25474   return jresult;
25475 }
25476
25477
25478 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25479   unsigned long jresult ;
25480   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25481   size_t result;
25482
25483   arg1 = (Dali::TextureSet *)jarg1;
25484   {
25485     try {
25486       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25487     } catch (std::out_of_range& e) {
25488       {
25489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25490       };
25491     } catch (std::exception& e) {
25492       {
25493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25494       };
25495     } catch (Dali::DaliException e) {
25496       {
25497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25498       };
25499     } catch (...) {
25500       {
25501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25502       };
25503     }
25504   }
25505
25506   jresult = (unsigned long)result;
25507   return jresult;
25508 }
25509
25510
25511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25512   void * jresult ;
25513   Dali::Property::Map *arg1 = 0 ;
25514   Dali::PropertyBuffer result;
25515
25516   arg1 = (Dali::Property::Map *)jarg1;
25517   if (!arg1) {
25518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25519     return 0;
25520   }
25521   {
25522     try {
25523       result = Dali::PropertyBuffer::New(*arg1);
25524     } catch (std::out_of_range& e) {
25525       {
25526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25527       };
25528     } catch (std::exception& e) {
25529       {
25530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25531       };
25532     } catch (Dali::DaliException e) {
25533       {
25534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25535       };
25536     } catch (...) {
25537       {
25538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25539       };
25540     }
25541   }
25542
25543   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25544   return jresult;
25545 }
25546
25547
25548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25549   void * jresult ;
25550   Dali::PropertyBuffer *result = 0 ;
25551
25552   {
25553     try {
25554       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25555     } catch (std::out_of_range& e) {
25556       {
25557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25558       };
25559     } catch (std::exception& e) {
25560       {
25561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25562       };
25563     } catch (Dali::DaliException e) {
25564       {
25565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25566       };
25567     } catch (...) {
25568       {
25569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25570       };
25571     }
25572   }
25573
25574   jresult = (void *)result;
25575   return jresult;
25576 }
25577
25578
25579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25580   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25581
25582   arg1 = (Dali::PropertyBuffer *)jarg1;
25583   {
25584     try {
25585       delete arg1;
25586     } catch (std::out_of_range& e) {
25587       {
25588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25589       };
25590     } catch (std::exception& e) {
25591       {
25592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25593       };
25594     } catch (Dali::DaliException e) {
25595       {
25596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25597       };
25598     } catch (...) {
25599       {
25600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25601       };
25602     }
25603   }
25604
25605 }
25606
25607
25608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25609   void * jresult ;
25610   Dali::PropertyBuffer *arg1 = 0 ;
25611   Dali::PropertyBuffer *result = 0 ;
25612
25613   arg1 = (Dali::PropertyBuffer *)jarg1;
25614   if (!arg1) {
25615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25616     return 0;
25617   }
25618   {
25619     try {
25620       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25621     } catch (std::out_of_range& e) {
25622       {
25623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25624       };
25625     } catch (std::exception& e) {
25626       {
25627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25628       };
25629     } catch (Dali::DaliException e) {
25630       {
25631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25632       };
25633     } catch (...) {
25634       {
25635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25636       };
25637     }
25638   }
25639
25640   jresult = (void *)result;
25641   return jresult;
25642 }
25643
25644
25645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25646   void * jresult ;
25647   Dali::BaseHandle arg1 ;
25648   Dali::BaseHandle *argp1 ;
25649   Dali::PropertyBuffer result;
25650
25651   argp1 = (Dali::BaseHandle *)jarg1;
25652   if (!argp1) {
25653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25654     return 0;
25655   }
25656   arg1 = *argp1;
25657   {
25658     try {
25659       result = Dali::PropertyBuffer::DownCast(arg1);
25660     } catch (std::out_of_range& e) {
25661       {
25662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25663       };
25664     } catch (std::exception& e) {
25665       {
25666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25667       };
25668     } catch (Dali::DaliException e) {
25669       {
25670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25671       };
25672     } catch (...) {
25673       {
25674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25675       };
25676     }
25677   }
25678
25679   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25680   return jresult;
25681 }
25682
25683
25684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25685   void * jresult ;
25686   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25687   Dali::PropertyBuffer *arg2 = 0 ;
25688   Dali::PropertyBuffer *result = 0 ;
25689
25690   arg1 = (Dali::PropertyBuffer *)jarg1;
25691   arg2 = (Dali::PropertyBuffer *)jarg2;
25692   if (!arg2) {
25693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25694     return 0;
25695   }
25696   {
25697     try {
25698       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25699     } catch (std::out_of_range& e) {
25700       {
25701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25702       };
25703     } catch (std::exception& e) {
25704       {
25705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25706       };
25707     } catch (Dali::DaliException e) {
25708       {
25709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25710       };
25711     } catch (...) {
25712       {
25713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25714       };
25715     }
25716   }
25717
25718   jresult = (void *)result;
25719   return jresult;
25720 }
25721
25722
25723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25724   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25725   void *arg2 = (void *) 0 ;
25726   std::size_t arg3 ;
25727
25728   arg1 = (Dali::PropertyBuffer *)jarg1;
25729   arg2 = jarg2;
25730   arg3 = (std::size_t)jarg3;
25731   {
25732     try {
25733       (arg1)->SetData((void const *)arg2,arg3);
25734     } catch (std::out_of_range& e) {
25735       {
25736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25737       };
25738     } catch (std::exception& e) {
25739       {
25740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25741       };
25742     } catch (Dali::DaliException e) {
25743       {
25744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25745       };
25746     } catch (...) {
25747       {
25748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25749       };
25750     }
25751   }
25752
25753 }
25754
25755
25756 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25757   unsigned long jresult ;
25758   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25759   std::size_t result;
25760
25761   arg1 = (Dali::PropertyBuffer *)jarg1;
25762   {
25763     try {
25764       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25765     } catch (std::out_of_range& e) {
25766       {
25767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25768       };
25769     } catch (std::exception& e) {
25770       {
25771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25772       };
25773     } catch (Dali::DaliException e) {
25774       {
25775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25776       };
25777     } catch (...) {
25778       {
25779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25780       };
25781     }
25782   }
25783
25784   jresult = (unsigned long)result;
25785   return jresult;
25786 }
25787
25788
25789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25790   void * jresult ;
25791   Dali::Geometry result;
25792
25793   {
25794     try {
25795       result = Dali::Geometry::New();
25796     } catch (std::out_of_range& e) {
25797       {
25798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25799       };
25800     } catch (std::exception& e) {
25801       {
25802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25803       };
25804     } catch (Dali::DaliException e) {
25805       {
25806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25807       };
25808     } catch (...) {
25809       {
25810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25811       };
25812     }
25813   }
25814
25815   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25816   return jresult;
25817 }
25818
25819
25820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25821   void * jresult ;
25822   Dali::Geometry *result = 0 ;
25823
25824   {
25825     try {
25826       result = (Dali::Geometry *)new Dali::Geometry();
25827     } catch (std::out_of_range& e) {
25828       {
25829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25830       };
25831     } catch (std::exception& e) {
25832       {
25833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25834       };
25835     } catch (Dali::DaliException e) {
25836       {
25837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25838       };
25839     } catch (...) {
25840       {
25841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25842       };
25843     }
25844   }
25845
25846   jresult = (void *)result;
25847   return jresult;
25848 }
25849
25850
25851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25852   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25853
25854   arg1 = (Dali::Geometry *)jarg1;
25855   {
25856     try {
25857       delete arg1;
25858     } catch (std::out_of_range& e) {
25859       {
25860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25861       };
25862     } catch (std::exception& e) {
25863       {
25864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25865       };
25866     } catch (Dali::DaliException e) {
25867       {
25868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25869       };
25870     } catch (...) {
25871       {
25872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25873       };
25874     }
25875   }
25876
25877 }
25878
25879
25880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25881   void * jresult ;
25882   Dali::Geometry *arg1 = 0 ;
25883   Dali::Geometry *result = 0 ;
25884
25885   arg1 = (Dali::Geometry *)jarg1;
25886   if (!arg1) {
25887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25888     return 0;
25889   }
25890   {
25891     try {
25892       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25893     } catch (std::out_of_range& e) {
25894       {
25895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25896       };
25897     } catch (std::exception& e) {
25898       {
25899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25900       };
25901     } catch (Dali::DaliException e) {
25902       {
25903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25904       };
25905     } catch (...) {
25906       {
25907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25908       };
25909     }
25910   }
25911
25912   jresult = (void *)result;
25913   return jresult;
25914 }
25915
25916
25917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25918   void * jresult ;
25919   Dali::BaseHandle arg1 ;
25920   Dali::BaseHandle *argp1 ;
25921   Dali::Geometry result;
25922
25923   argp1 = (Dali::BaseHandle *)jarg1;
25924   if (!argp1) {
25925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25926     return 0;
25927   }
25928   arg1 = *argp1;
25929   {
25930     try {
25931       result = Dali::Geometry::DownCast(arg1);
25932     } catch (std::out_of_range& e) {
25933       {
25934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25935       };
25936     } catch (std::exception& e) {
25937       {
25938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25939       };
25940     } catch (Dali::DaliException e) {
25941       {
25942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25943       };
25944     } catch (...) {
25945       {
25946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25947       };
25948     }
25949   }
25950
25951   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25952   return jresult;
25953 }
25954
25955
25956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25957   void * jresult ;
25958   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25959   Dali::Geometry *arg2 = 0 ;
25960   Dali::Geometry *result = 0 ;
25961
25962   arg1 = (Dali::Geometry *)jarg1;
25963   arg2 = (Dali::Geometry *)jarg2;
25964   if (!arg2) {
25965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25966     return 0;
25967   }
25968   {
25969     try {
25970       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
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 = (void *)result;
25991   return jresult;
25992 }
25993
25994
25995 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25996   unsigned long jresult ;
25997   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25998   Dali::PropertyBuffer *arg2 = 0 ;
25999   std::size_t result;
26000
26001   arg1 = (Dali::Geometry *)jarg1;
26002   arg2 = (Dali::PropertyBuffer *)jarg2;
26003   if (!arg2) {
26004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
26005     return 0;
26006   }
26007   {
26008     try {
26009       result = (arg1)->AddVertexBuffer(*arg2);
26010     } catch (std::out_of_range& e) {
26011       {
26012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26013       };
26014     } catch (std::exception& e) {
26015       {
26016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26017       };
26018     } catch (Dali::DaliException e) {
26019       {
26020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26021       };
26022     } catch (...) {
26023       {
26024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26025       };
26026     }
26027   }
26028
26029   jresult = (unsigned long)result;
26030   return jresult;
26031 }
26032
26033
26034 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
26035   unsigned long jresult ;
26036   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26037   std::size_t result;
26038
26039   arg1 = (Dali::Geometry *)jarg1;
26040   {
26041     try {
26042       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
26043     } catch (std::out_of_range& e) {
26044       {
26045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26046       };
26047     } catch (std::exception& e) {
26048       {
26049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26050       };
26051     } catch (Dali::DaliException e) {
26052       {
26053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26054       };
26055     } catch (...) {
26056       {
26057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26058       };
26059     }
26060   }
26061
26062   jresult = (unsigned long)result;
26063   return jresult;
26064 }
26065
26066
26067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
26068   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26069   std::size_t arg2 ;
26070
26071   arg1 = (Dali::Geometry *)jarg1;
26072   arg2 = (std::size_t)jarg2;
26073   {
26074     try {
26075       (arg1)->RemoveVertexBuffer(arg2);
26076     } catch (std::out_of_range& e) {
26077       {
26078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26079       };
26080     } catch (std::exception& e) {
26081       {
26082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26083       };
26084     } catch (Dali::DaliException e) {
26085       {
26086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26087       };
26088     } catch (...) {
26089       {
26090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26091       };
26092     }
26093   }
26094
26095 }
26096
26097
26098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26099   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26100   unsigned short *arg2 = (unsigned short *) 0 ;
26101   size_t arg3 ;
26102
26103   arg1 = (Dali::Geometry *)jarg1;
26104   arg2 = jarg2;
26105   arg3 = (size_t)jarg3;
26106   {
26107     try {
26108       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26109     } catch (std::out_of_range& e) {
26110       {
26111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26112       };
26113     } catch (std::exception& e) {
26114       {
26115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26116       };
26117     } catch (Dali::DaliException e) {
26118       {
26119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26120       };
26121     } catch (...) {
26122       {
26123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26124       };
26125     }
26126   }
26127
26128
26129
26130 }
26131
26132
26133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26134   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26135   Dali::Geometry::Type arg2 ;
26136
26137   arg1 = (Dali::Geometry *)jarg1;
26138   arg2 = (Dali::Geometry::Type)jarg2;
26139   {
26140     try {
26141       (arg1)->SetType(arg2);
26142     } catch (std::out_of_range& e) {
26143       {
26144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26145       };
26146     } catch (std::exception& e) {
26147       {
26148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26149       };
26150     } catch (Dali::DaliException e) {
26151       {
26152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26153       };
26154     } catch (...) {
26155       {
26156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26157       };
26158     }
26159   }
26160
26161 }
26162
26163
26164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26165   int jresult ;
26166   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26167   Dali::Geometry::Type result;
26168
26169   arg1 = (Dali::Geometry *)jarg1;
26170   {
26171     try {
26172       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26173     } catch (std::out_of_range& e) {
26174       {
26175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26176       };
26177     } catch (std::exception& e) {
26178       {
26179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26180       };
26181     } catch (Dali::DaliException e) {
26182       {
26183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26184       };
26185     } catch (...) {
26186       {
26187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26188       };
26189     }
26190   }
26191
26192   jresult = (int)result;
26193   return jresult;
26194 }
26195
26196
26197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26198   void * jresult ;
26199   Dali::Shader::Hint *result = 0 ;
26200
26201   {
26202     try {
26203       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26204     } catch (std::out_of_range& e) {
26205       {
26206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26207       };
26208     } catch (std::exception& e) {
26209       {
26210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26211       };
26212     } catch (Dali::DaliException e) {
26213       {
26214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26215       };
26216     } catch (...) {
26217       {
26218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26219       };
26220     }
26221   }
26222
26223   jresult = (void *)result;
26224   return jresult;
26225 }
26226
26227
26228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26229   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26230
26231   arg1 = (Dali::Shader::Hint *)jarg1;
26232   {
26233     try {
26234       delete arg1;
26235     } catch (std::out_of_range& e) {
26236       {
26237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26238       };
26239     } catch (std::exception& e) {
26240       {
26241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26242       };
26243     } catch (Dali::DaliException e) {
26244       {
26245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26246       };
26247     } catch (...) {
26248       {
26249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26250       };
26251     }
26252   }
26253
26254 }
26255
26256
26257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26258   int jresult ;
26259   int result;
26260
26261   result = (int)Dali::Shader::Property::PROGRAM;
26262   jresult = (int)result;
26263   return jresult;
26264 }
26265
26266
26267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26268   void * jresult ;
26269   Dali::Shader::Property *result = 0 ;
26270
26271   {
26272     try {
26273       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26274     } catch (std::out_of_range& e) {
26275       {
26276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26277       };
26278     } catch (std::exception& e) {
26279       {
26280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26281       };
26282     } catch (Dali::DaliException e) {
26283       {
26284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26285       };
26286     } catch (...) {
26287       {
26288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26289       };
26290     }
26291   }
26292
26293   jresult = (void *)result;
26294   return jresult;
26295 }
26296
26297
26298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26299   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26300
26301   arg1 = (Dali::Shader::Property *)jarg1;
26302   {
26303     try {
26304       delete arg1;
26305     } catch (std::out_of_range& e) {
26306       {
26307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26308       };
26309     } catch (std::exception& e) {
26310       {
26311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26312       };
26313     } catch (Dali::DaliException e) {
26314       {
26315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26316       };
26317     } catch (...) {
26318       {
26319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26320       };
26321     }
26322   }
26323
26324 }
26325
26326
26327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26328   void * jresult ;
26329   std::string *arg1 = 0 ;
26330   std::string *arg2 = 0 ;
26331   Dali::Shader::Hint::Value arg3 ;
26332   Dali::Shader result;
26333
26334   if (!jarg1) {
26335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26336     return 0;
26337   }
26338   std::string arg1_str(jarg1);
26339   arg1 = &arg1_str;
26340   if (!jarg2) {
26341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26342     return 0;
26343   }
26344   std::string arg2_str(jarg2);
26345   arg2 = &arg2_str;
26346   arg3 = (Dali::Shader::Hint::Value)jarg3;
26347   {
26348     try {
26349       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26350     } catch (std::out_of_range& e) {
26351       {
26352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26353       };
26354     } catch (std::exception& e) {
26355       {
26356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26357       };
26358     } catch (Dali::DaliException e) {
26359       {
26360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26361       };
26362     } catch (...) {
26363       {
26364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26365       };
26366     }
26367   }
26368
26369   jresult = new Dali::Shader((const Dali::Shader &)result);
26370
26371   //argout typemap for const std::string&
26372
26373
26374   //argout typemap for const std::string&
26375
26376   return jresult;
26377 }
26378
26379
26380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26381   void * jresult ;
26382   std::string *arg1 = 0 ;
26383   std::string *arg2 = 0 ;
26384   Dali::Shader result;
26385
26386   if (!jarg1) {
26387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26388     return 0;
26389   }
26390   std::string arg1_str(jarg1);
26391   arg1 = &arg1_str;
26392   if (!jarg2) {
26393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26394     return 0;
26395   }
26396   std::string arg2_str(jarg2);
26397   arg2 = &arg2_str;
26398   {
26399     try {
26400       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26401     } catch (std::out_of_range& e) {
26402       {
26403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26404       };
26405     } catch (std::exception& e) {
26406       {
26407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26408       };
26409     } catch (Dali::DaliException e) {
26410       {
26411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26412       };
26413     } catch (...) {
26414       {
26415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26416       };
26417     }
26418   }
26419
26420   jresult = new Dali::Shader((const Dali::Shader &)result);
26421
26422   //argout typemap for const std::string&
26423
26424
26425   //argout typemap for const std::string&
26426
26427   return jresult;
26428 }
26429
26430
26431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26432   void * jresult ;
26433   Dali::Shader *result = 0 ;
26434
26435   {
26436     try {
26437       result = (Dali::Shader *)new Dali::Shader();
26438     } catch (std::out_of_range& e) {
26439       {
26440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26441       };
26442     } catch (std::exception& e) {
26443       {
26444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26445       };
26446     } catch (Dali::DaliException e) {
26447       {
26448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26449       };
26450     } catch (...) {
26451       {
26452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26453       };
26454     }
26455   }
26456
26457   jresult = (void *)result;
26458   return jresult;
26459 }
26460
26461
26462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26463   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26464
26465   arg1 = (Dali::Shader *)jarg1;
26466   {
26467     try {
26468       delete arg1;
26469     } catch (std::out_of_range& e) {
26470       {
26471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26472       };
26473     } catch (std::exception& e) {
26474       {
26475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26476       };
26477     } catch (Dali::DaliException e) {
26478       {
26479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26480       };
26481     } catch (...) {
26482       {
26483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26484       };
26485     }
26486   }
26487
26488 }
26489
26490
26491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26492   void * jresult ;
26493   Dali::Shader *arg1 = 0 ;
26494   Dali::Shader *result = 0 ;
26495
26496   arg1 = (Dali::Shader *)jarg1;
26497   if (!arg1) {
26498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26499     return 0;
26500   }
26501   {
26502     try {
26503       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26504     } catch (std::out_of_range& e) {
26505       {
26506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26507       };
26508     } catch (std::exception& e) {
26509       {
26510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26511       };
26512     } catch (Dali::DaliException e) {
26513       {
26514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26515       };
26516     } catch (...) {
26517       {
26518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26519       };
26520     }
26521   }
26522
26523   jresult = (void *)result;
26524   return jresult;
26525 }
26526
26527
26528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26529   void * jresult ;
26530   Dali::BaseHandle arg1 ;
26531   Dali::BaseHandle *argp1 ;
26532   Dali::Shader result;
26533
26534   argp1 = (Dali::BaseHandle *)jarg1;
26535   if (!argp1) {
26536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26537     return 0;
26538   }
26539   arg1 = *argp1;
26540   {
26541     try {
26542       result = Dali::Shader::DownCast(arg1);
26543     } catch (std::out_of_range& e) {
26544       {
26545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26546       };
26547     } catch (std::exception& e) {
26548       {
26549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26550       };
26551     } catch (Dali::DaliException e) {
26552       {
26553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26554       };
26555     } catch (...) {
26556       {
26557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26558       };
26559     }
26560   }
26561
26562   jresult = new Dali::Shader((const Dali::Shader &)result);
26563   return jresult;
26564 }
26565
26566
26567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26568   void * jresult ;
26569   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26570   Dali::Shader *arg2 = 0 ;
26571   Dali::Shader *result = 0 ;
26572
26573   arg1 = (Dali::Shader *)jarg1;
26574   arg2 = (Dali::Shader *)jarg2;
26575   if (!arg2) {
26576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26577     return 0;
26578   }
26579   {
26580     try {
26581       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26582     } catch (std::out_of_range& e) {
26583       {
26584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26585       };
26586     } catch (std::exception& e) {
26587       {
26588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26589       };
26590     } catch (Dali::DaliException e) {
26591       {
26592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26593       };
26594     } catch (...) {
26595       {
26596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26597       };
26598     }
26599   }
26600
26601   jresult = (void *)result;
26602   return jresult;
26603 }
26604
26605
26606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
26607   int jresult ;
26608   int result;
26609
26610   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
26611   jresult = (int)result;
26612   return jresult;
26613 }
26614
26615
26616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
26617   int jresult ;
26618   int result;
26619
26620   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
26621   jresult = (int)result;
26622   return jresult;
26623 }
26624
26625
26626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
26627   int jresult ;
26628   int result;
26629
26630   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
26631   jresult = (int)result;
26632   return jresult;
26633 }
26634
26635
26636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
26637   int jresult ;
26638   int result;
26639
26640   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
26641   jresult = (int)result;
26642   return jresult;
26643 }
26644
26645
26646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
26647   int jresult ;
26648   int result;
26649
26650   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
26651   jresult = (int)result;
26652   return jresult;
26653 }
26654
26655
26656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26657   int jresult ;
26658   int result;
26659
26660   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26661   jresult = (int)result;
26662   return jresult;
26663 }
26664
26665
26666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26667   int jresult ;
26668   int result;
26669
26670   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26671   jresult = (int)result;
26672   return jresult;
26673 }
26674
26675
26676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26677   int jresult ;
26678   int result;
26679
26680   result = (int)Dali::Renderer::Property::BLEND_MODE;
26681   jresult = (int)result;
26682   return jresult;
26683 }
26684
26685
26686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26687   int jresult ;
26688   int result;
26689
26690   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26691   jresult = (int)result;
26692   return jresult;
26693 }
26694
26695
26696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26697   int jresult ;
26698   int result;
26699
26700   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26701   jresult = (int)result;
26702   return jresult;
26703 }
26704
26705
26706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26707   int jresult ;
26708   int result;
26709
26710   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26711   jresult = (int)result;
26712   return jresult;
26713 }
26714
26715
26716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26717   int jresult ;
26718   int result;
26719
26720   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26721   jresult = (int)result;
26722   return jresult;
26723 }
26724
26725
26726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26727   int jresult ;
26728   int result;
26729
26730   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26731   jresult = (int)result;
26732   return jresult;
26733 }
26734
26735
26736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26737   int jresult ;
26738   int result;
26739
26740   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26741   jresult = (int)result;
26742   return jresult;
26743 }
26744
26745
26746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26747   int jresult ;
26748   int result;
26749
26750   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26751   jresult = (int)result;
26752   return jresult;
26753 }
26754
26755
26756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26757   int jresult ;
26758   int result;
26759
26760   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26761   jresult = (int)result;
26762   return jresult;
26763 }
26764
26765
26766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26767   int jresult ;
26768   int result;
26769
26770   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26771   jresult = (int)result;
26772   return jresult;
26773 }
26774
26775
26776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26777   int jresult ;
26778   int result;
26779
26780   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26781   jresult = (int)result;
26782   return jresult;
26783 }
26784
26785
26786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26787   int jresult ;
26788   int result;
26789
26790   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26791   jresult = (int)result;
26792   return jresult;
26793 }
26794
26795
26796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26797   int jresult ;
26798   int result;
26799
26800   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26801   jresult = (int)result;
26802   return jresult;
26803 }
26804
26805
26806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26807   int jresult ;
26808   int result;
26809
26810   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26811   jresult = (int)result;
26812   return jresult;
26813 }
26814
26815
26816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26817   int jresult ;
26818   int result;
26819
26820   result = (int)Dali::Renderer::Property::RENDER_MODE;
26821   jresult = (int)result;
26822   return jresult;
26823 }
26824
26825
26826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26827   int jresult ;
26828   int result;
26829
26830   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26831   jresult = (int)result;
26832   return jresult;
26833 }
26834
26835
26836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26837   int jresult ;
26838   int result;
26839
26840   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26841   jresult = (int)result;
26842   return jresult;
26843 }
26844
26845
26846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26847   int jresult ;
26848   int result;
26849
26850   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26851   jresult = (int)result;
26852   return jresult;
26853 }
26854
26855
26856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26857   int jresult ;
26858   int result;
26859
26860   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26861   jresult = (int)result;
26862   return jresult;
26863 }
26864
26865
26866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26867   int jresult ;
26868   int result;
26869
26870   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26871   jresult = (int)result;
26872   return jresult;
26873 }
26874
26875
26876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26877   int jresult ;
26878   int result;
26879
26880   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26881   jresult = (int)result;
26882   return jresult;
26883 }
26884
26885
26886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26887   int jresult ;
26888   int result;
26889
26890   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26891   jresult = (int)result;
26892   return jresult;
26893 }
26894
26895
26896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26897   void * jresult ;
26898   Dali::Renderer::Property *result = 0 ;
26899
26900   {
26901     try {
26902       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
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 = (void *)result;
26923   return jresult;
26924 }
26925
26926
26927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26928   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26929
26930   arg1 = (Dali::Renderer::Property *)jarg1;
26931   {
26932     try {
26933       delete arg1;
26934     } catch (std::out_of_range& e) {
26935       {
26936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26937       };
26938     } catch (std::exception& e) {
26939       {
26940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26941       };
26942     } catch (Dali::DaliException e) {
26943       {
26944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26945       };
26946     } catch (...) {
26947       {
26948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26949       };
26950     }
26951   }
26952
26953 }
26954
26955
26956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26957   void * jresult ;
26958   Dali::Geometry *arg1 = 0 ;
26959   Dali::Shader *arg2 = 0 ;
26960   Dali::Renderer result;
26961
26962   arg1 = (Dali::Geometry *)jarg1;
26963   if (!arg1) {
26964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26965     return 0;
26966   }
26967   arg2 = (Dali::Shader *)jarg2;
26968   if (!arg2) {
26969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26970     return 0;
26971   }
26972   {
26973     try {
26974       result = Dali::Renderer::New(*arg1,*arg2);
26975     } catch (std::out_of_range& e) {
26976       {
26977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26978       };
26979     } catch (std::exception& e) {
26980       {
26981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26982       };
26983     } catch (Dali::DaliException e) {
26984       {
26985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26986       };
26987     } catch (...) {
26988       {
26989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26990       };
26991     }
26992   }
26993
26994   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26995   return jresult;
26996 }
26997
26998
26999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
27000   void * jresult ;
27001   Dali::Renderer *result = 0 ;
27002
27003   {
27004     try {
27005       result = (Dali::Renderer *)new Dali::Renderer();
27006     } catch (std::out_of_range& e) {
27007       {
27008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27009       };
27010     } catch (std::exception& e) {
27011       {
27012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27013       };
27014     } catch (Dali::DaliException e) {
27015       {
27016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27017       };
27018     } catch (...) {
27019       {
27020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27021       };
27022     }
27023   }
27024
27025   jresult = (void *)result;
27026   return jresult;
27027 }
27028
27029
27030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
27031   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27032
27033   arg1 = (Dali::Renderer *)jarg1;
27034   {
27035     try {
27036       delete arg1;
27037     } catch (std::out_of_range& e) {
27038       {
27039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27040       };
27041     } catch (std::exception& e) {
27042       {
27043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27044       };
27045     } catch (Dali::DaliException e) {
27046       {
27047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27048       };
27049     } catch (...) {
27050       {
27051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27052       };
27053     }
27054   }
27055
27056 }
27057
27058
27059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
27060   void * jresult ;
27061   Dali::Renderer *arg1 = 0 ;
27062   Dali::Renderer *result = 0 ;
27063
27064   arg1 = (Dali::Renderer *)jarg1;
27065   if (!arg1) {
27066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27067     return 0;
27068   }
27069   {
27070     try {
27071       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
27072     } catch (std::out_of_range& e) {
27073       {
27074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27075       };
27076     } catch (std::exception& e) {
27077       {
27078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27079       };
27080     } catch (Dali::DaliException e) {
27081       {
27082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27083       };
27084     } catch (...) {
27085       {
27086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27087       };
27088     }
27089   }
27090
27091   jresult = (void *)result;
27092   return jresult;
27093 }
27094
27095
27096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
27097   void * jresult ;
27098   Dali::BaseHandle arg1 ;
27099   Dali::BaseHandle *argp1 ;
27100   Dali::Renderer result;
27101
27102   argp1 = (Dali::BaseHandle *)jarg1;
27103   if (!argp1) {
27104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27105     return 0;
27106   }
27107   arg1 = *argp1;
27108   {
27109     try {
27110       result = Dali::Renderer::DownCast(arg1);
27111     } catch (std::out_of_range& e) {
27112       {
27113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27114       };
27115     } catch (std::exception& e) {
27116       {
27117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27118       };
27119     } catch (Dali::DaliException e) {
27120       {
27121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27122       };
27123     } catch (...) {
27124       {
27125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27126       };
27127     }
27128   }
27129
27130   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27131   return jresult;
27132 }
27133
27134
27135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27136   void * jresult ;
27137   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27138   Dali::Renderer *arg2 = 0 ;
27139   Dali::Renderer *result = 0 ;
27140
27141   arg1 = (Dali::Renderer *)jarg1;
27142   arg2 = (Dali::Renderer *)jarg2;
27143   if (!arg2) {
27144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27145     return 0;
27146   }
27147   {
27148     try {
27149       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
27150     } catch (std::out_of_range& e) {
27151       {
27152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27153       };
27154     } catch (std::exception& e) {
27155       {
27156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27157       };
27158     } catch (Dali::DaliException e) {
27159       {
27160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27161       };
27162     } catch (...) {
27163       {
27164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27165       };
27166     }
27167   }
27168
27169   jresult = (void *)result;
27170   return jresult;
27171 }
27172
27173
27174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27175   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27176   Dali::Geometry *arg2 = 0 ;
27177
27178   arg1 = (Dali::Renderer *)jarg1;
27179   arg2 = (Dali::Geometry *)jarg2;
27180   if (!arg2) {
27181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27182     return ;
27183   }
27184   {
27185     try {
27186       (arg1)->SetGeometry(*arg2);
27187     } catch (std::out_of_range& e) {
27188       {
27189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27190       };
27191     } catch (std::exception& e) {
27192       {
27193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27194       };
27195     } catch (Dali::DaliException e) {
27196       {
27197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27198       };
27199     } catch (...) {
27200       {
27201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27202       };
27203     }
27204   }
27205
27206 }
27207
27208
27209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27210   void * jresult ;
27211   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27212   Dali::Geometry result;
27213
27214   arg1 = (Dali::Renderer *)jarg1;
27215   {
27216     try {
27217       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27218     } catch (std::out_of_range& e) {
27219       {
27220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27221       };
27222     } catch (std::exception& e) {
27223       {
27224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27225       };
27226     } catch (Dali::DaliException e) {
27227       {
27228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27229       };
27230     } catch (...) {
27231       {
27232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27233       };
27234     }
27235   }
27236
27237   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27238   return jresult;
27239 }
27240
27241
27242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27243   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27244   int arg2 ;
27245   int arg3 ;
27246
27247   arg1 = (Dali::Renderer *)jarg1;
27248   arg2 = (int)jarg2;
27249   arg3 = (int)jarg3;
27250   {
27251     try {
27252       (arg1)->SetIndexRange(arg2,arg3);
27253     } catch (std::out_of_range& e) {
27254       {
27255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27256       };
27257     } catch (std::exception& e) {
27258       {
27259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27260       };
27261     } catch (Dali::DaliException e) {
27262       {
27263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27264       };
27265     } catch (...) {
27266       {
27267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27268       };
27269     }
27270   }
27271
27272 }
27273
27274
27275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27276   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27277   Dali::TextureSet *arg2 = 0 ;
27278
27279   arg1 = (Dali::Renderer *)jarg1;
27280   arg2 = (Dali::TextureSet *)jarg2;
27281   if (!arg2) {
27282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27283     return ;
27284   }
27285   {
27286     try {
27287       (arg1)->SetTextures(*arg2);
27288     } catch (std::out_of_range& e) {
27289       {
27290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27291       };
27292     } catch (std::exception& e) {
27293       {
27294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27295       };
27296     } catch (Dali::DaliException e) {
27297       {
27298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27299       };
27300     } catch (...) {
27301       {
27302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27303       };
27304     }
27305   }
27306
27307 }
27308
27309
27310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27311   void * jresult ;
27312   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27313   Dali::TextureSet result;
27314
27315   arg1 = (Dali::Renderer *)jarg1;
27316   {
27317     try {
27318       result = ((Dali::Renderer const *)arg1)->GetTextures();
27319     } catch (std::out_of_range& e) {
27320       {
27321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27322       };
27323     } catch (std::exception& e) {
27324       {
27325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27326       };
27327     } catch (Dali::DaliException e) {
27328       {
27329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27330       };
27331     } catch (...) {
27332       {
27333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27334       };
27335     }
27336   }
27337
27338   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27339   return jresult;
27340 }
27341
27342
27343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27344   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27345   Dali::Shader *arg2 = 0 ;
27346
27347   arg1 = (Dali::Renderer *)jarg1;
27348   arg2 = (Dali::Shader *)jarg2;
27349   if (!arg2) {
27350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27351     return ;
27352   }
27353   {
27354     try {
27355       (arg1)->SetShader(*arg2);
27356     } catch (std::out_of_range& e) {
27357       {
27358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27359       };
27360     } catch (std::exception& e) {
27361       {
27362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27363       };
27364     } catch (Dali::DaliException e) {
27365       {
27366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27367       };
27368     } catch (...) {
27369       {
27370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27371       };
27372     }
27373   }
27374
27375 }
27376
27377
27378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27379   void * jresult ;
27380   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27381   Dali::Shader result;
27382
27383   arg1 = (Dali::Renderer *)jarg1;
27384   {
27385     try {
27386       result = ((Dali::Renderer const *)arg1)->GetShader();
27387     } catch (std::out_of_range& e) {
27388       {
27389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27390       };
27391     } catch (std::exception& e) {
27392       {
27393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27394       };
27395     } catch (Dali::DaliException e) {
27396       {
27397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27398       };
27399     } catch (...) {
27400       {
27401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27402       };
27403     }
27404   }
27405
27406   jresult = new Dali::Shader((const Dali::Shader &)result);
27407   return jresult;
27408 }
27409
27410
27411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27412   void * jresult ;
27413   Dali::FrameBuffer::Attachment *result = 0 ;
27414
27415   {
27416     try {
27417       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27418     } catch (std::out_of_range& e) {
27419       {
27420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27421       };
27422     } catch (std::exception& e) {
27423       {
27424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27425       };
27426     } catch (Dali::DaliException e) {
27427       {
27428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27429       };
27430     } catch (...) {
27431       {
27432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27433       };
27434     }
27435   }
27436
27437   jresult = (void *)result;
27438   return jresult;
27439 }
27440
27441
27442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27443   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27444
27445   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27446   {
27447     try {
27448       delete arg1;
27449     } catch (std::out_of_range& e) {
27450       {
27451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27452       };
27453     } catch (std::exception& e) {
27454       {
27455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27456       };
27457     } catch (Dali::DaliException e) {
27458       {
27459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27460       };
27461     } catch (...) {
27462       {
27463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27464       };
27465     }
27466   }
27467
27468 }
27469
27470
27471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27472   void * jresult ;
27473   unsigned int arg1 ;
27474   unsigned int arg2 ;
27475   unsigned int arg3 ;
27476   Dali::FrameBuffer result;
27477
27478   arg1 = (unsigned int)jarg1;
27479   arg2 = (unsigned int)jarg2;
27480   arg3 = (unsigned int)jarg3;
27481   {
27482     try {
27483       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27484     } catch (std::out_of_range& e) {
27485       {
27486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27487       };
27488     } catch (std::exception& e) {
27489       {
27490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27491       };
27492     } catch (Dali::DaliException e) {
27493       {
27494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27495       };
27496     } catch (...) {
27497       {
27498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27499       };
27500     }
27501   }
27502
27503   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27504   return jresult;
27505 }
27506
27507
27508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27509   void * jresult ;
27510   Dali::FrameBuffer *result = 0 ;
27511
27512   {
27513     try {
27514       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27515     } catch (std::out_of_range& e) {
27516       {
27517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27518       };
27519     } catch (std::exception& e) {
27520       {
27521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27522       };
27523     } catch (Dali::DaliException e) {
27524       {
27525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27526       };
27527     } catch (...) {
27528       {
27529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27530       };
27531     }
27532   }
27533
27534   jresult = (void *)result;
27535   return jresult;
27536 }
27537
27538
27539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27540   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27541
27542   arg1 = (Dali::FrameBuffer *)jarg1;
27543   {
27544     try {
27545       delete arg1;
27546     } catch (std::out_of_range& e) {
27547       {
27548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27549       };
27550     } catch (std::exception& e) {
27551       {
27552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27553       };
27554     } catch (Dali::DaliException e) {
27555       {
27556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27557       };
27558     } catch (...) {
27559       {
27560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27561       };
27562     }
27563   }
27564
27565 }
27566
27567
27568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27569   void * jresult ;
27570   Dali::FrameBuffer *arg1 = 0 ;
27571   Dali::FrameBuffer *result = 0 ;
27572
27573   arg1 = (Dali::FrameBuffer *)jarg1;
27574   if (!arg1) {
27575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27576     return 0;
27577   }
27578   {
27579     try {
27580       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27581     } catch (std::out_of_range& e) {
27582       {
27583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27584       };
27585     } catch (std::exception& e) {
27586       {
27587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27588       };
27589     } catch (Dali::DaliException e) {
27590       {
27591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27592       };
27593     } catch (...) {
27594       {
27595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27596       };
27597     }
27598   }
27599
27600   jresult = (void *)result;
27601   return jresult;
27602 }
27603
27604
27605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27606   void * jresult ;
27607   Dali::BaseHandle arg1 ;
27608   Dali::BaseHandle *argp1 ;
27609   Dali::FrameBuffer result;
27610
27611   argp1 = (Dali::BaseHandle *)jarg1;
27612   if (!argp1) {
27613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27614     return 0;
27615   }
27616   arg1 = *argp1;
27617   {
27618     try {
27619       result = Dali::FrameBuffer::DownCast(arg1);
27620     } catch (std::out_of_range& e) {
27621       {
27622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27623       };
27624     } catch (std::exception& e) {
27625       {
27626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27627       };
27628     } catch (Dali::DaliException e) {
27629       {
27630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27631       };
27632     } catch (...) {
27633       {
27634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27635       };
27636     }
27637   }
27638
27639   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27640   return jresult;
27641 }
27642
27643
27644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27645   void * jresult ;
27646   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27647   Dali::FrameBuffer *arg2 = 0 ;
27648   Dali::FrameBuffer *result = 0 ;
27649
27650   arg1 = (Dali::FrameBuffer *)jarg1;
27651   arg2 = (Dali::FrameBuffer *)jarg2;
27652   if (!arg2) {
27653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27654     return 0;
27655   }
27656   {
27657     try {
27658       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27659     } catch (std::out_of_range& e) {
27660       {
27661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27662       };
27663     } catch (std::exception& e) {
27664       {
27665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27666       };
27667     } catch (Dali::DaliException e) {
27668       {
27669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27670       };
27671     } catch (...) {
27672       {
27673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27674       };
27675     }
27676   }
27677
27678   jresult = (void *)result;
27679   return jresult;
27680 }
27681
27682
27683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27684   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27685   Dali::Texture *arg2 = 0 ;
27686
27687   arg1 = (Dali::FrameBuffer *)jarg1;
27688   arg2 = (Dali::Texture *)jarg2;
27689   if (!arg2) {
27690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27691     return ;
27692   }
27693   {
27694     try {
27695       (arg1)->AttachColorTexture(*arg2);
27696     } catch (std::out_of_range& e) {
27697       {
27698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27699       };
27700     } catch (std::exception& e) {
27701       {
27702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27703       };
27704     } catch (Dali::DaliException e) {
27705       {
27706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27707       };
27708     } catch (...) {
27709       {
27710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27711       };
27712     }
27713   }
27714
27715 }
27716
27717
27718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27719   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27720   Dali::Texture *arg2 = 0 ;
27721   unsigned int arg3 ;
27722   unsigned int arg4 ;
27723
27724   arg1 = (Dali::FrameBuffer *)jarg1;
27725   arg2 = (Dali::Texture *)jarg2;
27726   if (!arg2) {
27727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27728     return ;
27729   }
27730   arg3 = (unsigned int)jarg3;
27731   arg4 = (unsigned int)jarg4;
27732   {
27733     try {
27734       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27735     } catch (std::out_of_range& e) {
27736       {
27737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27738       };
27739     } catch (std::exception& e) {
27740       {
27741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27742       };
27743     } catch (Dali::DaliException e) {
27744       {
27745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27746       };
27747     } catch (...) {
27748       {
27749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27750       };
27751     }
27752   }
27753
27754 }
27755
27756
27757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27758   void * jresult ;
27759   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27760   Dali::Texture result;
27761
27762   arg1 = (Dali::FrameBuffer *)jarg1;
27763   {
27764     try {
27765       result = (arg1)->GetColorTexture();
27766     } catch (std::out_of_range& e) {
27767       {
27768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27769       };
27770     } catch (std::exception& e) {
27771       {
27772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27773       };
27774     } catch (Dali::DaliException e) {
27775       {
27776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27777       };
27778     } catch (...) {
27779       {
27780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27781       };
27782     }
27783   }
27784
27785   jresult = new Dali::Texture((const Dali::Texture &)result);
27786   return jresult;
27787 }
27788
27789
27790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27791   void * jresult ;
27792   Dali::RenderTaskList *result = 0 ;
27793
27794   {
27795     try {
27796       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27797     } catch (std::out_of_range& e) {
27798       {
27799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27800       };
27801     } catch (std::exception& e) {
27802       {
27803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27804       };
27805     } catch (Dali::DaliException e) {
27806       {
27807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27808       };
27809     } catch (...) {
27810       {
27811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27812       };
27813     }
27814   }
27815
27816   jresult = (void *)result;
27817   return jresult;
27818 }
27819
27820
27821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27822   void * jresult ;
27823   Dali::BaseHandle arg1 ;
27824   Dali::BaseHandle *argp1 ;
27825   Dali::RenderTaskList result;
27826
27827   argp1 = (Dali::BaseHandle *)jarg1;
27828   if (!argp1) {
27829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27830     return 0;
27831   }
27832   arg1 = *argp1;
27833   {
27834     try {
27835       result = Dali::RenderTaskList::DownCast(arg1);
27836     } catch (std::out_of_range& e) {
27837       {
27838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27839       };
27840     } catch (std::exception& e) {
27841       {
27842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27843       };
27844     } catch (Dali::DaliException e) {
27845       {
27846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27847       };
27848     } catch (...) {
27849       {
27850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27851       };
27852     }
27853   }
27854
27855   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27856   return jresult;
27857 }
27858
27859
27860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27861   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27862
27863   arg1 = (Dali::RenderTaskList *)jarg1;
27864   {
27865     try {
27866       delete arg1;
27867     } catch (std::out_of_range& e) {
27868       {
27869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27870       };
27871     } catch (std::exception& e) {
27872       {
27873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27874       };
27875     } catch (Dali::DaliException e) {
27876       {
27877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27878       };
27879     } catch (...) {
27880       {
27881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27882       };
27883     }
27884   }
27885
27886 }
27887
27888
27889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27890   void * jresult ;
27891   Dali::RenderTaskList *arg1 = 0 ;
27892   Dali::RenderTaskList *result = 0 ;
27893
27894   arg1 = (Dali::RenderTaskList *)jarg1;
27895   if (!arg1) {
27896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27897     return 0;
27898   }
27899   {
27900     try {
27901       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
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 = (void *)result;
27922   return jresult;
27923 }
27924
27925
27926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27927   void * jresult ;
27928   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27929   Dali::RenderTaskList *arg2 = 0 ;
27930   Dali::RenderTaskList *result = 0 ;
27931
27932   arg1 = (Dali::RenderTaskList *)jarg1;
27933   arg2 = (Dali::RenderTaskList *)jarg2;
27934   if (!arg2) {
27935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27936     return 0;
27937   }
27938   {
27939     try {
27940       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27941     } catch (std::out_of_range& e) {
27942       {
27943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27944       };
27945     } catch (std::exception& e) {
27946       {
27947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27948       };
27949     } catch (Dali::DaliException e) {
27950       {
27951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27952       };
27953     } catch (...) {
27954       {
27955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27956       };
27957     }
27958   }
27959
27960   jresult = (void *)result;
27961   return jresult;
27962 }
27963
27964
27965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27966   void * jresult ;
27967   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27968   Dali::RenderTask result;
27969
27970   arg1 = (Dali::RenderTaskList *)jarg1;
27971   {
27972     try {
27973       result = (arg1)->CreateTask();
27974     } catch (std::out_of_range& e) {
27975       {
27976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27977       };
27978     } catch (std::exception& e) {
27979       {
27980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27981       };
27982     } catch (Dali::DaliException e) {
27983       {
27984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27985       };
27986     } catch (...) {
27987       {
27988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27989       };
27990     }
27991   }
27992
27993   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27994   return jresult;
27995 }
27996
27997
27998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27999   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
28000   Dali::RenderTask arg2 ;
28001   Dali::RenderTask *argp2 ;
28002
28003   arg1 = (Dali::RenderTaskList *)jarg1;
28004   argp2 = (Dali::RenderTask *)jarg2;
28005   if (!argp2) {
28006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
28007     return ;
28008   }
28009   arg2 = *argp2;
28010   {
28011     try {
28012       (arg1)->RemoveTask(arg2);
28013     } catch (std::out_of_range& e) {
28014       {
28015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28016       };
28017     } catch (std::exception& e) {
28018       {
28019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28020       };
28021     } catch (Dali::DaliException e) {
28022       {
28023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28024       };
28025     } catch (...) {
28026       {
28027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28028       };
28029     }
28030   }
28031
28032 }
28033
28034
28035 //// ===============================================end part 1 =================
28036
28037 //// ========================= part 2 ===============================
28038
28039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
28040   unsigned int jresult ;
28041   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
28042   unsigned int result;
28043
28044   arg1 = (Dali::RenderTaskList *)jarg1;
28045   {
28046     try {
28047       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
28048     } catch (std::out_of_range& e) {
28049       {
28050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28051       };
28052     } catch (std::exception& e) {
28053       {
28054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28055       };
28056     } catch (Dali::DaliException e) {
28057       {
28058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28059       };
28060     } catch (...) {
28061       {
28062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28063       };
28064     }
28065   }
28066
28067   jresult = result;
28068   return jresult;
28069 }
28070
28071
28072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
28073   void * jresult ;
28074   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
28075   unsigned int arg2 ;
28076   Dali::RenderTask result;
28077
28078   arg1 = (Dali::RenderTaskList *)jarg1;
28079   arg2 = (unsigned int)jarg2;
28080   {
28081     try {
28082       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
28083     } catch (std::out_of_range& e) {
28084       {
28085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28086       };
28087     } catch (std::exception& e) {
28088       {
28089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28090       };
28091     } catch (Dali::DaliException e) {
28092       {
28093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28094       };
28095     } catch (...) {
28096       {
28097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28098       };
28099     }
28100   }
28101
28102   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28103   return jresult;
28104 }
28105
28106
28107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
28108   int jresult ;
28109   int result;
28110
28111   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
28112   jresult = (int)result;
28113   return jresult;
28114 }
28115
28116
28117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
28118   int jresult ;
28119   int result;
28120
28121   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
28122   jresult = (int)result;
28123   return jresult;
28124 }
28125
28126
28127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
28128   int jresult ;
28129   int result;
28130
28131   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28132   jresult = (int)result;
28133   return jresult;
28134 }
28135
28136
28137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28138   int jresult ;
28139   int result;
28140
28141   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28142   jresult = (int)result;
28143   return jresult;
28144 }
28145
28146
28147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28148   void * jresult ;
28149   Dali::RenderTask::Property *result = 0 ;
28150
28151   {
28152     try {
28153       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
28154     } catch (std::out_of_range& e) {
28155       {
28156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28157       };
28158     } catch (std::exception& e) {
28159       {
28160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28161       };
28162     } catch (Dali::DaliException e) {
28163       {
28164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28165       };
28166     } catch (...) {
28167       {
28168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28169       };
28170     }
28171   }
28172
28173   jresult = (void *)result;
28174   return jresult;
28175 }
28176
28177
28178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28179   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28180
28181   arg1 = (Dali::RenderTask::Property *)jarg1;
28182   {
28183     try {
28184       delete arg1;
28185     } catch (std::out_of_range& e) {
28186       {
28187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28188       };
28189     } catch (std::exception& e) {
28190       {
28191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28192       };
28193     } catch (Dali::DaliException e) {
28194       {
28195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28196       };
28197     } catch (...) {
28198       {
28199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28200       };
28201     }
28202   }
28203
28204 }
28205
28206
28207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28208   void * jresult ;
28209   bool (*result)(Dali::Vector2 &) = 0 ;
28210
28211   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28212   jresult = (void *)result;
28213   return jresult;
28214 }
28215
28216
28217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28218   void * jresult ;
28219   bool (*result)(Dali::Vector2 &) = 0 ;
28220
28221   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28222   jresult = (void *)result;
28223   return jresult;
28224 }
28225
28226
28227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28228   unsigned int jresult ;
28229   bool result;
28230
28231   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28232   jresult = result;
28233   return jresult;
28234 }
28235
28236
28237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28238   unsigned int jresult ;
28239   bool result;
28240
28241   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28242   jresult = result;
28243   return jresult;
28244 }
28245
28246
28247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28248   void * jresult ;
28249   Dali::Vector4 *result = 0 ;
28250
28251   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28252   jresult = (void *)result;
28253   return jresult;
28254 }
28255
28256
28257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28258   unsigned int jresult ;
28259   bool result;
28260
28261   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28262   jresult = result;
28263   return jresult;
28264 }
28265
28266
28267 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28268   unsigned int jresult ;
28269   bool result;
28270
28271   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28272   jresult = result;
28273   return jresult;
28274 }
28275
28276
28277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28278   unsigned int jresult ;
28279   unsigned int result;
28280
28281   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28282   jresult = result;
28283   return jresult;
28284 }
28285
28286
28287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28288   void * jresult ;
28289   Dali::RenderTask *result = 0 ;
28290
28291   {
28292     try {
28293       result = (Dali::RenderTask *)new Dali::RenderTask();
28294     } catch (std::out_of_range& e) {
28295       {
28296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28297       };
28298     } catch (std::exception& e) {
28299       {
28300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28301       };
28302     } catch (Dali::DaliException e) {
28303       {
28304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28305       };
28306     } catch (...) {
28307       {
28308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28309       };
28310     }
28311   }
28312
28313   jresult = (void *)result;
28314   return jresult;
28315 }
28316
28317
28318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28319   void * jresult ;
28320   Dali::BaseHandle arg1 ;
28321   Dali::BaseHandle *argp1 ;
28322   Dali::RenderTask result;
28323
28324   argp1 = (Dali::BaseHandle *)jarg1;
28325   if (!argp1) {
28326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28327     return 0;
28328   }
28329   arg1 = *argp1;
28330   {
28331     try {
28332       result = Dali::RenderTask::DownCast(arg1);
28333     } catch (std::out_of_range& e) {
28334       {
28335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28336       };
28337     } catch (std::exception& e) {
28338       {
28339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28340       };
28341     } catch (Dali::DaliException e) {
28342       {
28343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28344       };
28345     } catch (...) {
28346       {
28347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28348       };
28349     }
28350   }
28351
28352   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28353   return jresult;
28354 }
28355
28356
28357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28358   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28359
28360   arg1 = (Dali::RenderTask *)jarg1;
28361   {
28362     try {
28363       delete arg1;
28364     } catch (std::out_of_range& e) {
28365       {
28366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28367       };
28368     } catch (std::exception& e) {
28369       {
28370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28371       };
28372     } catch (Dali::DaliException e) {
28373       {
28374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28375       };
28376     } catch (...) {
28377       {
28378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28379       };
28380     }
28381   }
28382
28383 }
28384
28385
28386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28387   void * jresult ;
28388   Dali::RenderTask *arg1 = 0 ;
28389   Dali::RenderTask *result = 0 ;
28390
28391   arg1 = (Dali::RenderTask *)jarg1;
28392   if (!arg1) {
28393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28394     return 0;
28395   }
28396   {
28397     try {
28398       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28399     } catch (std::out_of_range& e) {
28400       {
28401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28402       };
28403     } catch (std::exception& e) {
28404       {
28405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28406       };
28407     } catch (Dali::DaliException e) {
28408       {
28409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28410       };
28411     } catch (...) {
28412       {
28413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28414       };
28415     }
28416   }
28417
28418   jresult = (void *)result;
28419   return jresult;
28420 }
28421
28422
28423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28424   void * jresult ;
28425   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28426   Dali::RenderTask *arg2 = 0 ;
28427   Dali::RenderTask *result = 0 ;
28428
28429   arg1 = (Dali::RenderTask *)jarg1;
28430   arg2 = (Dali::RenderTask *)jarg2;
28431   if (!arg2) {
28432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28433     return 0;
28434   }
28435   {
28436     try {
28437       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28438     } catch (std::out_of_range& e) {
28439       {
28440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28441       };
28442     } catch (std::exception& e) {
28443       {
28444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28445       };
28446     } catch (Dali::DaliException e) {
28447       {
28448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28449       };
28450     } catch (...) {
28451       {
28452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28453       };
28454     }
28455   }
28456
28457   jresult = (void *)result;
28458   return jresult;
28459 }
28460
28461
28462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28463   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28464   Dali::Actor arg2 ;
28465   Dali::Actor *argp2 ;
28466
28467   arg1 = (Dali::RenderTask *)jarg1;
28468   argp2 = (Dali::Actor *)jarg2;
28469   if (!argp2) {
28470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28471     return ;
28472   }
28473   arg2 = *argp2;
28474   {
28475     try {
28476       (arg1)->SetSourceActor(arg2);
28477     } catch (std::out_of_range& e) {
28478       {
28479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28480       };
28481     } catch (std::exception& e) {
28482       {
28483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28484       };
28485     } catch (Dali::DaliException e) {
28486       {
28487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28488       };
28489     } catch (...) {
28490       {
28491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28492       };
28493     }
28494   }
28495
28496 }
28497
28498
28499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28500   void * jresult ;
28501   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28502   Dali::Actor result;
28503
28504   arg1 = (Dali::RenderTask *)jarg1;
28505   {
28506     try {
28507       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28508     } catch (std::out_of_range& e) {
28509       {
28510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28511       };
28512     } catch (std::exception& e) {
28513       {
28514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28515       };
28516     } catch (Dali::DaliException e) {
28517       {
28518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28519       };
28520     } catch (...) {
28521       {
28522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28523       };
28524     }
28525   }
28526
28527   jresult = new Dali::Actor((const Dali::Actor &)result);
28528   return jresult;
28529 }
28530
28531
28532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28533   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28534   bool arg2 ;
28535
28536   arg1 = (Dali::RenderTask *)jarg1;
28537   arg2 = jarg2 ? true : false;
28538   {
28539     try {
28540       (arg1)->SetExclusive(arg2);
28541     } catch (std::out_of_range& e) {
28542       {
28543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28544       };
28545     } catch (std::exception& e) {
28546       {
28547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28548       };
28549     } catch (Dali::DaliException e) {
28550       {
28551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28552       };
28553     } catch (...) {
28554       {
28555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28556       };
28557     }
28558   }
28559
28560 }
28561
28562
28563 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28564   unsigned int jresult ;
28565   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28566   bool result;
28567
28568   arg1 = (Dali::RenderTask *)jarg1;
28569   {
28570     try {
28571       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28572     } catch (std::out_of_range& e) {
28573       {
28574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28575       };
28576     } catch (std::exception& e) {
28577       {
28578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28579       };
28580     } catch (Dali::DaliException e) {
28581       {
28582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28583       };
28584     } catch (...) {
28585       {
28586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28587       };
28588     }
28589   }
28590
28591   jresult = result;
28592   return jresult;
28593 }
28594
28595
28596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28597   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28598   bool arg2 ;
28599
28600   arg1 = (Dali::RenderTask *)jarg1;
28601   arg2 = jarg2 ? true : false;
28602   {
28603     try {
28604       (arg1)->SetInputEnabled(arg2);
28605     } catch (std::out_of_range& e) {
28606       {
28607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28608       };
28609     } catch (std::exception& e) {
28610       {
28611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28612       };
28613     } catch (Dali::DaliException e) {
28614       {
28615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28616       };
28617     } catch (...) {
28618       {
28619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28620       };
28621     }
28622   }
28623
28624 }
28625
28626
28627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28628   unsigned int jresult ;
28629   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28630   bool result;
28631
28632   arg1 = (Dali::RenderTask *)jarg1;
28633   {
28634     try {
28635       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28636     } catch (std::out_of_range& e) {
28637       {
28638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28639       };
28640     } catch (std::exception& e) {
28641       {
28642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28643       };
28644     } catch (Dali::DaliException e) {
28645       {
28646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28647       };
28648     } catch (...) {
28649       {
28650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28651       };
28652     }
28653   }
28654
28655   jresult = result;
28656   return jresult;
28657 }
28658
28659
28660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28661   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28662   Dali::CameraActor arg2 ;
28663   Dali::CameraActor *argp2 ;
28664
28665   arg1 = (Dali::RenderTask *)jarg1;
28666   argp2 = (Dali::CameraActor *)jarg2;
28667   if (!argp2) {
28668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28669     return ;
28670   }
28671   arg2 = *argp2;
28672   {
28673     try {
28674       (arg1)->SetCameraActor(arg2);
28675     } catch (std::out_of_range& e) {
28676       {
28677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28678       };
28679     } catch (std::exception& e) {
28680       {
28681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28682       };
28683     } catch (Dali::DaliException e) {
28684       {
28685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28686       };
28687     } catch (...) {
28688       {
28689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28690       };
28691     }
28692   }
28693
28694 }
28695
28696
28697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28698   void * jresult ;
28699   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28700   Dali::CameraActor result;
28701
28702   arg1 = (Dali::RenderTask *)jarg1;
28703   {
28704     try {
28705       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28706     } catch (std::out_of_range& e) {
28707       {
28708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28709       };
28710     } catch (std::exception& e) {
28711       {
28712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28713       };
28714     } catch (Dali::DaliException e) {
28715       {
28716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28717       };
28718     } catch (...) {
28719       {
28720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28721       };
28722     }
28723   }
28724
28725   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28726   return jresult;
28727 }
28728
28729
28730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28731   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28732   Dali::FrameBufferImage arg2 ;
28733   Dali::FrameBufferImage *argp2 ;
28734
28735   arg1 = (Dali::RenderTask *)jarg1;
28736   argp2 = (Dali::FrameBufferImage *)jarg2;
28737   if (!argp2) {
28738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28739     return ;
28740   }
28741   arg2 = *argp2;
28742   {
28743     try {
28744       (arg1)->SetTargetFrameBuffer(arg2);
28745     } catch (std::out_of_range& e) {
28746       {
28747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28748       };
28749     } catch (std::exception& e) {
28750       {
28751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28752       };
28753     } catch (Dali::DaliException e) {
28754       {
28755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28756       };
28757     } catch (...) {
28758       {
28759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28760       };
28761     }
28762   }
28763
28764 }
28765
28766
28767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28768   void * jresult ;
28769   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28770   Dali::FrameBufferImage result;
28771
28772   arg1 = (Dali::RenderTask *)jarg1;
28773   {
28774     try {
28775       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28776     } catch (std::out_of_range& e) {
28777       {
28778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28779       };
28780     } catch (std::exception& e) {
28781       {
28782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28783       };
28784     } catch (Dali::DaliException e) {
28785       {
28786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28787       };
28788     } catch (...) {
28789       {
28790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28791       };
28792     }
28793   }
28794
28795   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28796   return jresult;
28797 }
28798
28799
28800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28801   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28802   Dali::FrameBuffer arg2 ;
28803   Dali::FrameBuffer *argp2 ;
28804
28805   arg1 = (Dali::RenderTask *)jarg1;
28806   argp2 = (Dali::FrameBuffer *)jarg2;
28807   if (!argp2) {
28808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28809     return ;
28810   }
28811   arg2 = *argp2;
28812   {
28813     try {
28814       (arg1)->SetFrameBuffer(arg2);
28815     } catch (std::out_of_range& e) {
28816       {
28817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28818       };
28819     } catch (std::exception& e) {
28820       {
28821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28822       };
28823     } catch (Dali::DaliException e) {
28824       {
28825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28826       };
28827     } catch (...) {
28828       {
28829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28830       };
28831     }
28832   }
28833
28834 }
28835
28836
28837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28838   void * jresult ;
28839   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28840   Dali::FrameBuffer result;
28841
28842   arg1 = (Dali::RenderTask *)jarg1;
28843   {
28844     try {
28845       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28846     } catch (std::out_of_range& e) {
28847       {
28848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28849       };
28850     } catch (std::exception& e) {
28851       {
28852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28853       };
28854     } catch (Dali::DaliException e) {
28855       {
28856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28857       };
28858     } catch (...) {
28859       {
28860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28861       };
28862     }
28863   }
28864
28865   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28866   return jresult;
28867 }
28868
28869
28870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28871   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28872   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28873
28874   arg1 = (Dali::RenderTask *)jarg1;
28875   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28876   {
28877     try {
28878       (arg1)->SetScreenToFrameBufferFunction(arg2);
28879     } catch (std::out_of_range& e) {
28880       {
28881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28882       };
28883     } catch (std::exception& e) {
28884       {
28885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28886       };
28887     } catch (Dali::DaliException e) {
28888       {
28889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28890       };
28891     } catch (...) {
28892       {
28893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28894       };
28895     }
28896   }
28897
28898 }
28899
28900
28901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28902   void * jresult ;
28903   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28904   Dali::RenderTask::ScreenToFrameBufferFunction result;
28905
28906   arg1 = (Dali::RenderTask *)jarg1;
28907   {
28908     try {
28909       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28910     } catch (std::out_of_range& e) {
28911       {
28912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28913       };
28914     } catch (std::exception& e) {
28915       {
28916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28917       };
28918     } catch (Dali::DaliException e) {
28919       {
28920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28921       };
28922     } catch (...) {
28923       {
28924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28925       };
28926     }
28927   }
28928
28929   jresult = (void *)result;
28930   return jresult;
28931 }
28932
28933
28934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28935   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28936   Dali::Actor arg2 ;
28937   Dali::Actor *argp2 ;
28938
28939   arg1 = (Dali::RenderTask *)jarg1;
28940   argp2 = (Dali::Actor *)jarg2;
28941   if (!argp2) {
28942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28943     return ;
28944   }
28945   arg2 = *argp2;
28946   {
28947     try {
28948       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28949     } catch (std::out_of_range& e) {
28950       {
28951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28952       };
28953     } catch (std::exception& e) {
28954       {
28955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28956       };
28957     } catch (Dali::DaliException e) {
28958       {
28959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28960       };
28961     } catch (...) {
28962       {
28963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28964       };
28965     }
28966   }
28967
28968 }
28969
28970
28971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28972   void * jresult ;
28973   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28974   Dali::Actor result;
28975
28976   arg1 = (Dali::RenderTask *)jarg1;
28977   {
28978     try {
28979       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28980     } catch (std::out_of_range& e) {
28981       {
28982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28983       };
28984     } catch (std::exception& e) {
28985       {
28986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28987       };
28988     } catch (Dali::DaliException e) {
28989       {
28990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28991       };
28992     } catch (...) {
28993       {
28994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28995       };
28996     }
28997   }
28998
28999   jresult = new Dali::Actor((const Dali::Actor &)result);
29000   return jresult;
29001 }
29002
29003
29004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
29005   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29006   Dali::Vector2 arg2 ;
29007   Dali::Vector2 *argp2 ;
29008
29009   arg1 = (Dali::RenderTask *)jarg1;
29010   argp2 = (Dali::Vector2 *)jarg2;
29011   if (!argp2) {
29012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
29013     return ;
29014   }
29015   arg2 = *argp2;
29016   {
29017     try {
29018       (arg1)->SetViewportPosition(arg2);
29019     } catch (std::out_of_range& e) {
29020       {
29021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29022       };
29023     } catch (std::exception& e) {
29024       {
29025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29026       };
29027     } catch (Dali::DaliException e) {
29028       {
29029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29030       };
29031     } catch (...) {
29032       {
29033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29034       };
29035     }
29036   }
29037
29038 }
29039
29040
29041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
29042   void * jresult ;
29043   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29044   Dali::Vector2 result;
29045
29046   arg1 = (Dali::RenderTask *)jarg1;
29047   {
29048     try {
29049       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
29050     } catch (std::out_of_range& e) {
29051       {
29052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29053       };
29054     } catch (std::exception& e) {
29055       {
29056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29057       };
29058     } catch (Dali::DaliException e) {
29059       {
29060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29061       };
29062     } catch (...) {
29063       {
29064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29065       };
29066     }
29067   }
29068
29069   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29070   return jresult;
29071 }
29072
29073
29074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
29075   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29076   Dali::Vector2 arg2 ;
29077   Dali::Vector2 *argp2 ;
29078
29079   arg1 = (Dali::RenderTask *)jarg1;
29080   argp2 = (Dali::Vector2 *)jarg2;
29081   if (!argp2) {
29082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
29083     return ;
29084   }
29085   arg2 = *argp2;
29086   {
29087     try {
29088       (arg1)->SetViewportSize(arg2);
29089     } catch (std::out_of_range& e) {
29090       {
29091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29092       };
29093     } catch (std::exception& e) {
29094       {
29095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29096       };
29097     } catch (Dali::DaliException e) {
29098       {
29099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29100       };
29101     } catch (...) {
29102       {
29103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29104       };
29105     }
29106   }
29107
29108 }
29109
29110
29111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
29112   void * jresult ;
29113   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29114   Dali::Vector2 result;
29115
29116   arg1 = (Dali::RenderTask *)jarg1;
29117   {
29118     try {
29119       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
29120     } catch (std::out_of_range& e) {
29121       {
29122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29123       };
29124     } catch (std::exception& e) {
29125       {
29126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29127       };
29128     } catch (Dali::DaliException e) {
29129       {
29130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29131       };
29132     } catch (...) {
29133       {
29134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29135       };
29136     }
29137   }
29138
29139   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29140   return jresult;
29141 }
29142
29143
29144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29145   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29146   Dali::Viewport arg2 ;
29147   Dali::Viewport *argp2 ;
29148
29149   arg1 = (Dali::RenderTask *)jarg1;
29150   argp2 = (Dali::Viewport *)jarg2;
29151   if (!argp2) {
29152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29153     return ;
29154   }
29155   arg2 = *argp2;
29156   {
29157     try {
29158       (arg1)->SetViewport(arg2);
29159     } catch (std::out_of_range& e) {
29160       {
29161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29162       };
29163     } catch (std::exception& e) {
29164       {
29165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29166       };
29167     } catch (Dali::DaliException e) {
29168       {
29169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29170       };
29171     } catch (...) {
29172       {
29173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29174       };
29175     }
29176   }
29177
29178 }
29179
29180
29181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29182   void * jresult ;
29183   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29184   Dali::Viewport result;
29185
29186   arg1 = (Dali::RenderTask *)jarg1;
29187   {
29188     try {
29189       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29190     } catch (std::out_of_range& e) {
29191       {
29192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29193       };
29194     } catch (std::exception& e) {
29195       {
29196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29197       };
29198     } catch (Dali::DaliException e) {
29199       {
29200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29201       };
29202     } catch (...) {
29203       {
29204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29205       };
29206     }
29207   }
29208
29209   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29210   return jresult;
29211 }
29212
29213
29214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29215   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29216   Dali::Vector4 *arg2 = 0 ;
29217
29218   arg1 = (Dali::RenderTask *)jarg1;
29219   arg2 = (Dali::Vector4 *)jarg2;
29220   if (!arg2) {
29221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29222     return ;
29223   }
29224   {
29225     try {
29226       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29227     } catch (std::out_of_range& e) {
29228       {
29229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29230       };
29231     } catch (std::exception& e) {
29232       {
29233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29234       };
29235     } catch (Dali::DaliException e) {
29236       {
29237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29238       };
29239     } catch (...) {
29240       {
29241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29242       };
29243     }
29244   }
29245
29246 }
29247
29248
29249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29250   void * jresult ;
29251   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29252   Dali::Vector4 result;
29253
29254   arg1 = (Dali::RenderTask *)jarg1;
29255   {
29256     try {
29257       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29258     } catch (std::out_of_range& e) {
29259       {
29260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29261       };
29262     } catch (std::exception& e) {
29263       {
29264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29265       };
29266     } catch (Dali::DaliException e) {
29267       {
29268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29269       };
29270     } catch (...) {
29271       {
29272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29273       };
29274     }
29275   }
29276
29277   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29278   return jresult;
29279 }
29280
29281
29282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29283   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29284   bool arg2 ;
29285
29286   arg1 = (Dali::RenderTask *)jarg1;
29287   arg2 = jarg2 ? true : false;
29288   {
29289     try {
29290       (arg1)->SetClearEnabled(arg2);
29291     } catch (std::out_of_range& e) {
29292       {
29293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29294       };
29295     } catch (std::exception& e) {
29296       {
29297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29298       };
29299     } catch (Dali::DaliException e) {
29300       {
29301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29302       };
29303     } catch (...) {
29304       {
29305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29306       };
29307     }
29308   }
29309
29310 }
29311
29312
29313 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29314   unsigned int jresult ;
29315   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29316   bool result;
29317
29318   arg1 = (Dali::RenderTask *)jarg1;
29319   {
29320     try {
29321       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29322     } catch (std::out_of_range& e) {
29323       {
29324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29325       };
29326     } catch (std::exception& e) {
29327       {
29328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29329       };
29330     } catch (Dali::DaliException e) {
29331       {
29332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29333       };
29334     } catch (...) {
29335       {
29336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29337       };
29338     }
29339   }
29340
29341   jresult = result;
29342   return jresult;
29343 }
29344
29345
29346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29347   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29348   bool arg2 ;
29349
29350   arg1 = (Dali::RenderTask *)jarg1;
29351   arg2 = jarg2 ? true : false;
29352   {
29353     try {
29354       (arg1)->SetCullMode(arg2);
29355     } catch (std::out_of_range& e) {
29356       {
29357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29358       };
29359     } catch (std::exception& e) {
29360       {
29361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29362       };
29363     } catch (Dali::DaliException e) {
29364       {
29365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29366       };
29367     } catch (...) {
29368       {
29369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29370       };
29371     }
29372   }
29373
29374 }
29375
29376
29377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29378   unsigned int jresult ;
29379   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29380   bool result;
29381
29382   arg1 = (Dali::RenderTask *)jarg1;
29383   {
29384     try {
29385       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29386     } catch (std::out_of_range& e) {
29387       {
29388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29389       };
29390     } catch (std::exception& e) {
29391       {
29392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29393       };
29394     } catch (Dali::DaliException e) {
29395       {
29396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29397       };
29398     } catch (...) {
29399       {
29400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29401       };
29402     }
29403   }
29404
29405   jresult = result;
29406   return jresult;
29407 }
29408
29409
29410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29411   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29412   unsigned int arg2 ;
29413
29414   arg1 = (Dali::RenderTask *)jarg1;
29415   arg2 = (unsigned int)jarg2;
29416   {
29417     try {
29418       (arg1)->SetRefreshRate(arg2);
29419     } catch (std::out_of_range& e) {
29420       {
29421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29422       };
29423     } catch (std::exception& e) {
29424       {
29425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29426       };
29427     } catch (Dali::DaliException e) {
29428       {
29429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29430       };
29431     } catch (...) {
29432       {
29433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29434       };
29435     }
29436   }
29437
29438 }
29439
29440
29441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29442   unsigned int jresult ;
29443   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29444   unsigned int result;
29445
29446   arg1 = (Dali::RenderTask *)jarg1;
29447   {
29448     try {
29449       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29450     } catch (std::out_of_range& e) {
29451       {
29452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29453       };
29454     } catch (std::exception& e) {
29455       {
29456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29457       };
29458     } catch (Dali::DaliException e) {
29459       {
29460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29461       };
29462     } catch (...) {
29463       {
29464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29465       };
29466     }
29467   }
29468
29469   jresult = result;
29470   return jresult;
29471 }
29472
29473
29474 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29475   unsigned int jresult ;
29476   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29477   Dali::Vector3 *arg2 = 0 ;
29478   float *arg3 = 0 ;
29479   float *arg4 = 0 ;
29480   bool result;
29481
29482   arg1 = (Dali::RenderTask *)jarg1;
29483   arg2 = (Dali::Vector3 *)jarg2;
29484   if (!arg2) {
29485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29486     return 0;
29487   }
29488   arg3 = (float *)jarg3;
29489   arg4 = (float *)jarg4;
29490   {
29491     try {
29492       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29493     } catch (std::out_of_range& e) {
29494       {
29495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29496       };
29497     } catch (std::exception& e) {
29498       {
29499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29500       };
29501     } catch (Dali::DaliException e) {
29502       {
29503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29504       };
29505     } catch (...) {
29506       {
29507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29508       };
29509     }
29510   }
29511
29512   jresult = result;
29513   return jresult;
29514 }
29515
29516
29517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29518   unsigned int jresult ;
29519   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29520   Dali::Actor arg2 ;
29521   float arg3 ;
29522   float arg4 ;
29523   float *arg5 = 0 ;
29524   float *arg6 = 0 ;
29525   Dali::Actor *argp2 ;
29526   bool result;
29527
29528   arg1 = (Dali::RenderTask *)jarg1;
29529   argp2 = (Dali::Actor *)jarg2;
29530   if (!argp2) {
29531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29532     return 0;
29533   }
29534   arg2 = *argp2;
29535   arg3 = (float)jarg3;
29536   arg4 = (float)jarg4;
29537   arg5 = (float *)jarg5;
29538   arg6 = (float *)jarg6;
29539   {
29540     try {
29541       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
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 = result;
29562   return jresult;
29563 }
29564
29565
29566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29567   void * jresult ;
29568   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29569   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29570
29571   arg1 = (Dali::RenderTask *)jarg1;
29572   {
29573     try {
29574       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29575     } catch (std::out_of_range& e) {
29576       {
29577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29578       };
29579     } catch (std::exception& e) {
29580       {
29581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29582       };
29583     } catch (Dali::DaliException e) {
29584       {
29585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29586       };
29587     } catch (...) {
29588       {
29589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29590       };
29591     }
29592   }
29593
29594   jresult = (void *)result;
29595   return jresult;
29596 }
29597
29598
29599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29600   void * jresult ;
29601   int arg1 ;
29602   Dali::TouchPoint::State arg2 ;
29603   float arg3 ;
29604   float arg4 ;
29605   Dali::TouchPoint *result = 0 ;
29606
29607   arg1 = (int)jarg1;
29608   arg2 = (Dali::TouchPoint::State)jarg2;
29609   arg3 = (float)jarg3;
29610   arg4 = (float)jarg4;
29611   {
29612     try {
29613       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29614     } catch (std::out_of_range& e) {
29615       {
29616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29617       };
29618     } catch (std::exception& e) {
29619       {
29620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29621       };
29622     } catch (Dali::DaliException e) {
29623       {
29624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29625       };
29626     } catch (...) {
29627       {
29628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29629       };
29630     }
29631   }
29632
29633   jresult = (void *)result;
29634   return jresult;
29635 }
29636
29637
29638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29639   void * jresult ;
29640   int arg1 ;
29641   Dali::TouchPoint::State arg2 ;
29642   float arg3 ;
29643   float arg4 ;
29644   float arg5 ;
29645   float arg6 ;
29646   Dali::TouchPoint *result = 0 ;
29647
29648   arg1 = (int)jarg1;
29649   arg2 = (Dali::TouchPoint::State)jarg2;
29650   arg3 = (float)jarg3;
29651   arg4 = (float)jarg4;
29652   arg5 = (float)jarg5;
29653   arg6 = (float)jarg6;
29654   {
29655     try {
29656       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29657     } catch (std::out_of_range& e) {
29658       {
29659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29660       };
29661     } catch (std::exception& e) {
29662       {
29663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29664       };
29665     } catch (Dali::DaliException e) {
29666       {
29667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29668       };
29669     } catch (...) {
29670       {
29671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29672       };
29673     }
29674   }
29675
29676   jresult = (void *)result;
29677   return jresult;
29678 }
29679
29680
29681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29682   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29683
29684   arg1 = (Dali::TouchPoint *)jarg1;
29685   {
29686     try {
29687       delete arg1;
29688     } catch (std::out_of_range& e) {
29689       {
29690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29691       };
29692     } catch (std::exception& e) {
29693       {
29694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29695       };
29696     } catch (Dali::DaliException e) {
29697       {
29698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29699       };
29700     } catch (...) {
29701       {
29702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29703       };
29704     }
29705   }
29706
29707 }
29708
29709
29710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29711   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29712   int arg2 ;
29713
29714   arg1 = (Dali::TouchPoint *)jarg1;
29715   arg2 = (int)jarg2;
29716   if (arg1) (arg1)->deviceId = arg2;
29717 }
29718
29719
29720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29721   int jresult ;
29722   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29723   int result;
29724
29725   arg1 = (Dali::TouchPoint *)jarg1;
29726   result = (int) ((arg1)->deviceId);
29727   jresult = result;
29728   return jresult;
29729 }
29730
29731
29732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29733   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29734   Dali::TouchPoint::State arg2 ;
29735
29736   arg1 = (Dali::TouchPoint *)jarg1;
29737   arg2 = (Dali::TouchPoint::State)jarg2;
29738   if (arg1) (arg1)->state = arg2;
29739 }
29740
29741
29742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29743   int jresult ;
29744   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29745   Dali::TouchPoint::State result;
29746
29747   arg1 = (Dali::TouchPoint *)jarg1;
29748   result = (Dali::TouchPoint::State) ((arg1)->state);
29749   jresult = (int)result;
29750   return jresult;
29751 }
29752
29753
29754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29755   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29756   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29757
29758   arg1 = (Dali::TouchPoint *)jarg1;
29759   arg2 = (Dali::Actor *)jarg2;
29760   if (arg1) (arg1)->hitActor = *arg2;
29761 }
29762
29763
29764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29765   void * jresult ;
29766   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29767   Dali::Actor *result = 0 ;
29768
29769   arg1 = (Dali::TouchPoint *)jarg1;
29770   result = (Dali::Actor *)& ((arg1)->hitActor);
29771   jresult = (void *)result;
29772   return jresult;
29773 }
29774
29775
29776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29777   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29778   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29779
29780   arg1 = (Dali::TouchPoint *)jarg1;
29781   arg2 = (Dali::Vector2 *)jarg2;
29782   if (arg1) (arg1)->local = *arg2;
29783 }
29784
29785
29786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29787   void * jresult ;
29788   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29789   Dali::Vector2 *result = 0 ;
29790
29791   arg1 = (Dali::TouchPoint *)jarg1;
29792   result = (Dali::Vector2 *)& ((arg1)->local);
29793   jresult = (void *)result;
29794   return jresult;
29795 }
29796
29797
29798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29799   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29800   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29801
29802   arg1 = (Dali::TouchPoint *)jarg1;
29803   arg2 = (Dali::Vector2 *)jarg2;
29804   if (arg1) (arg1)->screen = *arg2;
29805 }
29806
29807
29808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29809   void * jresult ;
29810   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29811   Dali::Vector2 *result = 0 ;
29812
29813   arg1 = (Dali::TouchPoint *)jarg1;
29814   result = (Dali::Vector2 *)& ((arg1)->screen);
29815   jresult = (void *)result;
29816   return jresult;
29817 }
29818
29819
29820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29821   void * jresult ;
29822   Dali::TouchData *result = 0 ;
29823
29824   {
29825     try {
29826       result = (Dali::TouchData *)new Dali::TouchData();
29827     } catch (std::out_of_range& e) {
29828       {
29829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29830       };
29831     } catch (std::exception& e) {
29832       {
29833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29834       };
29835     } catch (Dali::DaliException e) {
29836       {
29837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29838       };
29839     } catch (...) {
29840       {
29841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29842       };
29843     }
29844   }
29845
29846   jresult = (void *)result;
29847   return jresult;
29848 }
29849
29850
29851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29852   void * jresult ;
29853   Dali::TouchData *arg1 = 0 ;
29854   Dali::TouchData *result = 0 ;
29855
29856   arg1 = (Dali::TouchData *)jarg1;
29857   if (!arg1) {
29858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29859     return 0;
29860   }
29861   {
29862     try {
29863       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29864     } catch (std::out_of_range& e) {
29865       {
29866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29867       };
29868     } catch (std::exception& e) {
29869       {
29870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29871       };
29872     } catch (Dali::DaliException e) {
29873       {
29874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29875       };
29876     } catch (...) {
29877       {
29878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29879       };
29880     }
29881   }
29882
29883   jresult = (void *)result;
29884   return jresult;
29885 }
29886
29887
29888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29889   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29890
29891   arg1 = (Dali::TouchData *)jarg1;
29892   {
29893     try {
29894       delete arg1;
29895     } catch (std::out_of_range& e) {
29896       {
29897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29898       };
29899     } catch (std::exception& e) {
29900       {
29901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29902       };
29903     } catch (Dali::DaliException e) {
29904       {
29905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29906       };
29907     } catch (...) {
29908       {
29909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29910       };
29911     }
29912   }
29913
29914 }
29915
29916
29917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29918   void * jresult ;
29919   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29920   Dali::TouchData *arg2 = 0 ;
29921   Dali::TouchData *result = 0 ;
29922
29923   arg1 = (Dali::TouchData *)jarg1;
29924   arg2 = (Dali::TouchData *)jarg2;
29925   if (!arg2) {
29926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29927     return 0;
29928   }
29929   {
29930     try {
29931       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29932     } catch (std::out_of_range& e) {
29933       {
29934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29935       };
29936     } catch (std::exception& e) {
29937       {
29938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29939       };
29940     } catch (Dali::DaliException e) {
29941       {
29942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29943       };
29944     } catch (...) {
29945       {
29946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29947       };
29948     }
29949   }
29950
29951   jresult = (void *)result;
29952   return jresult;
29953 }
29954
29955
29956 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29957   unsigned long jresult ;
29958   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29959   unsigned long result;
29960
29961   arg1 = (Dali::TouchData *)jarg1;
29962   {
29963     try {
29964       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29965     } catch (std::out_of_range& e) {
29966       {
29967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29968       };
29969     } catch (std::exception& e) {
29970       {
29971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29972       };
29973     } catch (Dali::DaliException e) {
29974       {
29975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29976       };
29977     } catch (...) {
29978       {
29979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29980       };
29981     }
29982   }
29983
29984   jresult = (unsigned long)result;
29985   return jresult;
29986 }
29987
29988
29989 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29990   unsigned long jresult ;
29991   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29992   std::size_t result;
29993
29994   arg1 = (Dali::TouchData *)jarg1;
29995   {
29996     try {
29997       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29998     } catch (std::out_of_range& e) {
29999       {
30000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30001       };
30002     } catch (std::exception& e) {
30003       {
30004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30005       };
30006     } catch (Dali::DaliException e) {
30007       {
30008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30009       };
30010     } catch (...) {
30011       {
30012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30013       };
30014     }
30015   }
30016
30017   jresult = (unsigned long)result;
30018   return jresult;
30019 }
30020
30021
30022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
30023   int jresult ;
30024   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30025   std::size_t arg2 ;
30026   int32_t result;
30027
30028   arg1 = (Dali::TouchData *)jarg1;
30029   arg2 = (std::size_t)jarg2;
30030   {
30031     try {
30032       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
30033     } catch (std::out_of_range& e) {
30034       {
30035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30036       };
30037     } catch (std::exception& e) {
30038       {
30039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30040       };
30041     } catch (Dali::DaliException e) {
30042       {
30043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30044       };
30045     } catch (...) {
30046       {
30047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30048       };
30049     }
30050   }
30051
30052   jresult = result;
30053   return jresult;
30054 }
30055
30056
30057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
30058   int jresult ;
30059   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30060   std::size_t arg2 ;
30061   Dali::PointState::Type result;
30062
30063   arg1 = (Dali::TouchData *)jarg1;
30064   arg2 = (std::size_t)jarg2;
30065   {
30066     try {
30067       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
30068     } catch (std::out_of_range& e) {
30069       {
30070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30071       };
30072     } catch (std::exception& e) {
30073       {
30074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30075       };
30076     } catch (Dali::DaliException e) {
30077       {
30078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30079       };
30080     } catch (...) {
30081       {
30082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30083       };
30084     }
30085   }
30086
30087   jresult = (int)result;
30088   return jresult;
30089 }
30090
30091
30092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
30093   void * jresult ;
30094   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30095   std::size_t arg2 ;
30096   Dali::Actor result;
30097
30098   arg1 = (Dali::TouchData *)jarg1;
30099   arg2 = (std::size_t)jarg2;
30100   {
30101     try {
30102       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
30103     } catch (std::out_of_range& e) {
30104       {
30105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30106       };
30107     } catch (std::exception& e) {
30108       {
30109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30110       };
30111     } catch (Dali::DaliException e) {
30112       {
30113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30114       };
30115     } catch (...) {
30116       {
30117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30118       };
30119     }
30120   }
30121
30122   jresult = new Dali::Actor((const Dali::Actor &)result);
30123   return jresult;
30124 }
30125
30126
30127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30128   void * jresult ;
30129   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30130   std::size_t arg2 ;
30131   Dali::Vector2 *result = 0 ;
30132
30133   arg1 = (Dali::TouchData *)jarg1;
30134   arg2 = (std::size_t)jarg2;
30135   {
30136     try {
30137       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30138     } catch (std::out_of_range& e) {
30139       {
30140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30141       };
30142     } catch (std::exception& e) {
30143       {
30144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30145       };
30146     } catch (Dali::DaliException e) {
30147       {
30148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30149       };
30150     } catch (...) {
30151       {
30152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30153       };
30154     }
30155   }
30156
30157   jresult = (void *)result;
30158   return jresult;
30159 }
30160
30161
30162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30163   void * jresult ;
30164   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30165   std::size_t arg2 ;
30166   Dali::Vector2 *result = 0 ;
30167
30168   arg1 = (Dali::TouchData *)jarg1;
30169   arg2 = (std::size_t)jarg2;
30170   {
30171     try {
30172       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30173     } catch (std::out_of_range& e) {
30174       {
30175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30176       };
30177     } catch (std::exception& e) {
30178       {
30179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30180       };
30181     } catch (Dali::DaliException e) {
30182       {
30183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30184       };
30185     } catch (...) {
30186       {
30187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30188       };
30189     }
30190   }
30191
30192   jresult = (void *)result;
30193   return jresult;
30194 }
30195
30196
30197 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30198   float jresult ;
30199   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30200   std::size_t arg2 ;
30201   float result;
30202
30203   arg1 = (Dali::TouchData *)jarg1;
30204   arg2 = (std::size_t)jarg2;
30205   {
30206     try {
30207       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30208     } catch (std::out_of_range& e) {
30209       {
30210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30211       };
30212     } catch (std::exception& e) {
30213       {
30214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30215       };
30216     } catch (Dali::DaliException e) {
30217       {
30218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30219       };
30220     } catch (...) {
30221       {
30222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30223       };
30224     }
30225   }
30226
30227   jresult = result;
30228   return jresult;
30229 }
30230
30231
30232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30233   void * jresult ;
30234   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30235   std::size_t arg2 ;
30236   Dali::Vector2 *result = 0 ;
30237
30238   arg1 = (Dali::TouchData *)jarg1;
30239   arg2 = (std::size_t)jarg2;
30240   {
30241     try {
30242       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30243     } catch (std::out_of_range& e) {
30244       {
30245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30246       };
30247     } catch (std::exception& e) {
30248       {
30249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30250       };
30251     } catch (Dali::DaliException e) {
30252       {
30253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30254       };
30255     } catch (...) {
30256       {
30257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30258       };
30259     }
30260   }
30261
30262   jresult = (void *)result;
30263   return jresult;
30264 }
30265
30266
30267 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30268   float jresult ;
30269   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30270   std::size_t arg2 ;
30271   float result;
30272
30273   arg1 = (Dali::TouchData *)jarg1;
30274   arg2 = (std::size_t)jarg2;
30275   {
30276     try {
30277       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30278     } catch (std::out_of_range& e) {
30279       {
30280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30281       };
30282     } catch (std::exception& e) {
30283       {
30284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30285       };
30286     } catch (Dali::DaliException e) {
30287       {
30288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30289       };
30290     } catch (...) {
30291       {
30292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30293       };
30294     }
30295   }
30296
30297   jresult = result;
30298   return jresult;
30299 }
30300
30301
30302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30303   void * jresult ;
30304   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30305   std::size_t arg2 ;
30306   Dali::Degree result;
30307
30308   arg1 = (Dali::TouchData *)jarg1;
30309   arg2 = (std::size_t)jarg2;
30310   {
30311     try {
30312       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30313     } catch (std::out_of_range& e) {
30314       {
30315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30316       };
30317     } catch (std::exception& e) {
30318       {
30319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30320       };
30321     } catch (Dali::DaliException e) {
30322       {
30323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30324       };
30325     } catch (...) {
30326       {
30327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30328       };
30329     }
30330   }
30331
30332   jresult = new Dali::Degree((const Dali::Degree &)result);
30333   return jresult;
30334 }
30335
30336
30337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
30338   int jresult ;
30339   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30340   std::size_t arg2 ;
30341   Dali::MouseButton::Type result;
30342
30343   arg1 = (Dali::TouchData *)jarg1;
30344   arg2 = (std::size_t)jarg2;
30345   {
30346     try {
30347       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
30348     } catch (std::out_of_range& e) {
30349       {
30350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30351       };
30352     } catch (std::exception& e) {
30353       {
30354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30355       };
30356     } catch (Dali::DaliException e) {
30357       {
30358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30359       };
30360     } catch (...) {
30361       {
30362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30363       };
30364     }
30365   }
30366
30367   jresult = static_cast< int >(result);
30368   return jresult;
30369 }
30370
30371
30372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30373   void * jresult ;
30374   Dali::GestureDetector *result = 0 ;
30375
30376   {
30377     try {
30378       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30379     } catch (std::out_of_range& e) {
30380       {
30381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30382       };
30383     } catch (std::exception& e) {
30384       {
30385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30386       };
30387     } catch (Dali::DaliException e) {
30388       {
30389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30390       };
30391     } catch (...) {
30392       {
30393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30394       };
30395     }
30396   }
30397
30398   jresult = (void *)result;
30399   return jresult;
30400 }
30401
30402
30403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30404   void * jresult ;
30405   Dali::BaseHandle arg1 ;
30406   Dali::BaseHandle *argp1 ;
30407   Dali::GestureDetector result;
30408
30409   argp1 = (Dali::BaseHandle *)jarg1;
30410   if (!argp1) {
30411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30412     return 0;
30413   }
30414   arg1 = *argp1;
30415   {
30416     try {
30417       result = Dali::GestureDetector::DownCast(arg1);
30418     } catch (std::out_of_range& e) {
30419       {
30420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30421       };
30422     } catch (std::exception& e) {
30423       {
30424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30425       };
30426     } catch (Dali::DaliException e) {
30427       {
30428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30429       };
30430     } catch (...) {
30431       {
30432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30433       };
30434     }
30435   }
30436
30437   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30438   return jresult;
30439 }
30440
30441
30442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30443   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30444
30445   arg1 = (Dali::GestureDetector *)jarg1;
30446   {
30447     try {
30448       delete arg1;
30449     } catch (std::out_of_range& e) {
30450       {
30451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30452       };
30453     } catch (std::exception& e) {
30454       {
30455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30456       };
30457     } catch (Dali::DaliException e) {
30458       {
30459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30460       };
30461     } catch (...) {
30462       {
30463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30464       };
30465     }
30466   }
30467
30468 }
30469
30470
30471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30472   void * jresult ;
30473   Dali::GestureDetector *arg1 = 0 ;
30474   Dali::GestureDetector *result = 0 ;
30475
30476   arg1 = (Dali::GestureDetector *)jarg1;
30477   if (!arg1) {
30478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30479     return 0;
30480   }
30481   {
30482     try {
30483       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30484     } catch (std::out_of_range& e) {
30485       {
30486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30487       };
30488     } catch (std::exception& e) {
30489       {
30490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30491       };
30492     } catch (Dali::DaliException e) {
30493       {
30494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30495       };
30496     } catch (...) {
30497       {
30498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30499       };
30500     }
30501   }
30502
30503   jresult = (void *)result;
30504   return jresult;
30505 }
30506
30507
30508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30509   void * jresult ;
30510   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30511   Dali::GestureDetector *arg2 = 0 ;
30512   Dali::GestureDetector *result = 0 ;
30513
30514   arg1 = (Dali::GestureDetector *)jarg1;
30515   arg2 = (Dali::GestureDetector *)jarg2;
30516   if (!arg2) {
30517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30518     return 0;
30519   }
30520   {
30521     try {
30522       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30523     } catch (std::out_of_range& e) {
30524       {
30525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30526       };
30527     } catch (std::exception& e) {
30528       {
30529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30530       };
30531     } catch (Dali::DaliException e) {
30532       {
30533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30534       };
30535     } catch (...) {
30536       {
30537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30538       };
30539     }
30540   }
30541
30542   jresult = (void *)result;
30543   return jresult;
30544 }
30545
30546
30547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30548   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30549   Dali::Actor arg2 ;
30550   Dali::Actor *argp2 ;
30551
30552   arg1 = (Dali::GestureDetector *)jarg1;
30553   argp2 = (Dali::Actor *)jarg2;
30554   if (!argp2) {
30555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30556     return ;
30557   }
30558   arg2 = *argp2;
30559   {
30560     try {
30561       (arg1)->Attach(arg2);
30562     } catch (std::out_of_range& e) {
30563       {
30564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30565       };
30566     } catch (std::exception& e) {
30567       {
30568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30569       };
30570     } catch (Dali::DaliException e) {
30571       {
30572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30573       };
30574     } catch (...) {
30575       {
30576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30577       };
30578     }
30579   }
30580
30581 }
30582
30583
30584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30585   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30586   Dali::Actor arg2 ;
30587   Dali::Actor *argp2 ;
30588
30589   arg1 = (Dali::GestureDetector *)jarg1;
30590   argp2 = (Dali::Actor *)jarg2;
30591   if (!argp2) {
30592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30593     return ;
30594   }
30595   arg2 = *argp2;
30596   {
30597     try {
30598       (arg1)->Detach(arg2);
30599     } catch (std::out_of_range& e) {
30600       {
30601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30602       };
30603     } catch (std::exception& e) {
30604       {
30605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30606       };
30607     } catch (Dali::DaliException e) {
30608       {
30609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30610       };
30611     } catch (...) {
30612       {
30613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30614       };
30615     }
30616   }
30617
30618 }
30619
30620
30621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30622   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30623
30624   arg1 = (Dali::GestureDetector *)jarg1;
30625   {
30626     try {
30627       (arg1)->DetachAll();
30628     } catch (std::out_of_range& e) {
30629       {
30630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30631       };
30632     } catch (std::exception& e) {
30633       {
30634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30635       };
30636     } catch (Dali::DaliException e) {
30637       {
30638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30639       };
30640     } catch (...) {
30641       {
30642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30643       };
30644     }
30645   }
30646
30647 }
30648
30649
30650 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30651   unsigned long jresult ;
30652   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30653   size_t result;
30654
30655   arg1 = (Dali::GestureDetector *)jarg1;
30656   {
30657     try {
30658       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
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 = (unsigned long)result;
30679   return jresult;
30680 }
30681
30682
30683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30684   void * jresult ;
30685   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30686   size_t arg2 ;
30687   Dali::Actor result;
30688
30689   arg1 = (Dali::GestureDetector *)jarg1;
30690   arg2 = (size_t)jarg2;
30691   {
30692     try {
30693       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30694     } catch (std::out_of_range& e) {
30695       {
30696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30697       };
30698     } catch (std::exception& e) {
30699       {
30700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30701       };
30702     } catch (Dali::DaliException e) {
30703       {
30704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30705       };
30706     } catch (...) {
30707       {
30708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30709       };
30710     }
30711   }
30712
30713   jresult = new Dali::Actor((const Dali::Actor &)result);
30714   return jresult;
30715 }
30716
30717
30718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30719   void * jresult ;
30720   Dali::Gesture *arg1 = 0 ;
30721   Dali::Gesture *result = 0 ;
30722
30723   arg1 = (Dali::Gesture *)jarg1;
30724   if (!arg1) {
30725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30726     return 0;
30727   }
30728   {
30729     try {
30730       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30731     } catch (std::out_of_range& e) {
30732       {
30733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30734       };
30735     } catch (std::exception& e) {
30736       {
30737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30738       };
30739     } catch (Dali::DaliException e) {
30740       {
30741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30742       };
30743     } catch (...) {
30744       {
30745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30746       };
30747     }
30748   }
30749
30750   jresult = (void *)result;
30751   return jresult;
30752 }
30753
30754
30755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30756   void * jresult ;
30757   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30758   Dali::Gesture *arg2 = 0 ;
30759   Dali::Gesture *result = 0 ;
30760
30761   arg1 = (Dali::Gesture *)jarg1;
30762   arg2 = (Dali::Gesture *)jarg2;
30763   if (!arg2) {
30764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30765     return 0;
30766   }
30767   {
30768     try {
30769       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30770     } catch (std::out_of_range& e) {
30771       {
30772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30773       };
30774     } catch (std::exception& e) {
30775       {
30776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30777       };
30778     } catch (Dali::DaliException e) {
30779       {
30780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30781       };
30782     } catch (...) {
30783       {
30784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30785       };
30786     }
30787   }
30788
30789   jresult = (void *)result;
30790   return jresult;
30791 }
30792
30793
30794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30795   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30796
30797   arg1 = (Dali::Gesture *)jarg1;
30798   {
30799     try {
30800       delete arg1;
30801     } catch (std::out_of_range& e) {
30802       {
30803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30804       };
30805     } catch (std::exception& e) {
30806       {
30807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30808       };
30809     } catch (Dali::DaliException e) {
30810       {
30811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30812       };
30813     } catch (...) {
30814       {
30815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30816       };
30817     }
30818   }
30819
30820 }
30821
30822
30823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30824   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30825   Dali::Gesture::Type arg2 ;
30826
30827   arg1 = (Dali::Gesture *)jarg1;
30828   arg2 = (Dali::Gesture::Type)jarg2;
30829   if (arg1) (arg1)->type = arg2;
30830 }
30831
30832
30833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30834   int jresult ;
30835   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30836   Dali::Gesture::Type result;
30837
30838   arg1 = (Dali::Gesture *)jarg1;
30839   result = (Dali::Gesture::Type) ((arg1)->type);
30840   jresult = (int)result;
30841   return jresult;
30842 }
30843
30844
30845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30846   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30847   Dali::Gesture::State arg2 ;
30848
30849   arg1 = (Dali::Gesture *)jarg1;
30850   arg2 = (Dali::Gesture::State)jarg2;
30851   if (arg1) (arg1)->state = arg2;
30852 }
30853
30854
30855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30856   int jresult ;
30857   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30858   Dali::Gesture::State result;
30859
30860   arg1 = (Dali::Gesture *)jarg1;
30861   result = (Dali::Gesture::State) ((arg1)->state);
30862   jresult = (int)result;
30863   return jresult;
30864 }
30865
30866
30867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30868   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30869   unsigned int arg2 ;
30870
30871   arg1 = (Dali::Gesture *)jarg1;
30872   arg2 = (unsigned int)jarg2;
30873   if (arg1) (arg1)->time = arg2;
30874 }
30875
30876
30877 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30878   unsigned int jresult ;
30879   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30880   unsigned int result;
30881
30882   arg1 = (Dali::Gesture *)jarg1;
30883   result = (unsigned int) ((arg1)->time);
30884   jresult = result;
30885   return jresult;
30886 }
30887
30888
30889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30890   void * jresult ;
30891   Dali::HoverEvent *result = 0 ;
30892
30893   {
30894     try {
30895       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30896     } catch (std::out_of_range& e) {
30897       {
30898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30899       };
30900     } catch (std::exception& e) {
30901       {
30902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30903       };
30904     } catch (Dali::DaliException e) {
30905       {
30906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30907       };
30908     } catch (...) {
30909       {
30910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30911       };
30912     }
30913   }
30914
30915   jresult = (void *)result;
30916   return jresult;
30917 }
30918
30919
30920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30921   void * jresult ;
30922   unsigned long arg1 ;
30923   Dali::HoverEvent *result = 0 ;
30924
30925   arg1 = (unsigned long)jarg1;
30926   {
30927     try {
30928       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30929     } catch (std::out_of_range& e) {
30930       {
30931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30932       };
30933     } catch (std::exception& e) {
30934       {
30935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30936       };
30937     } catch (Dali::DaliException e) {
30938       {
30939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30940       };
30941     } catch (...) {
30942       {
30943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30944       };
30945     }
30946   }
30947
30948   jresult = (void *)result;
30949   return jresult;
30950 }
30951
30952
30953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30954   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30955
30956   arg1 = (Dali::HoverEvent *)jarg1;
30957   {
30958     try {
30959       delete arg1;
30960     } catch (std::out_of_range& e) {
30961       {
30962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30963       };
30964     } catch (std::exception& e) {
30965       {
30966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30967       };
30968     } catch (Dali::DaliException e) {
30969       {
30970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30971       };
30972     } catch (...) {
30973       {
30974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30975       };
30976     }
30977   }
30978
30979 }
30980
30981
30982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30983   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30984   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30985
30986   arg1 = (Dali::HoverEvent *)jarg1;
30987   arg2 = (Dali::TouchPointContainer *)jarg2;
30988   if (arg1) (arg1)->points = *arg2;
30989 }
30990
30991
30992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30993   void * jresult ;
30994   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30995   Dali::TouchPointContainer *result = 0 ;
30996
30997   arg1 = (Dali::HoverEvent *)jarg1;
30998   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30999   jresult = (void *)result;
31000   return jresult;
31001 }
31002
31003
31004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
31005   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
31006   unsigned long arg2 ;
31007
31008   arg1 = (Dali::HoverEvent *)jarg1;
31009   arg2 = (unsigned long)jarg2;
31010   if (arg1) (arg1)->time = arg2;
31011 }
31012
31013
31014 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
31015   unsigned long jresult ;
31016   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
31017   unsigned long result;
31018
31019   arg1 = (Dali::HoverEvent *)jarg1;
31020   result = (unsigned long) ((arg1)->time);
31021   jresult = (unsigned long)result;
31022   return jresult;
31023 }
31024
31025
31026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
31027   unsigned int jresult ;
31028   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
31029   unsigned int result;
31030
31031   arg1 = (Dali::HoverEvent *)jarg1;
31032   {
31033     try {
31034       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
31035     } catch (std::out_of_range& e) {
31036       {
31037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31038       };
31039     } catch (std::exception& e) {
31040       {
31041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31042       };
31043     } catch (Dali::DaliException e) {
31044       {
31045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31046       };
31047     } catch (...) {
31048       {
31049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31050       };
31051     }
31052   }
31053
31054   jresult = result;
31055   return jresult;
31056 }
31057
31058
31059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
31060   void * jresult ;
31061   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
31062   unsigned int arg2 ;
31063   Dali::TouchPoint *result = 0 ;
31064
31065   arg1 = (Dali::HoverEvent *)jarg1;
31066   arg2 = (unsigned int)jarg2;
31067   {
31068     try {
31069       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
31070     } catch (std::out_of_range& e) {
31071       {
31072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31073       };
31074     } catch (std::exception& e) {
31075       {
31076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31077       };
31078     } catch (Dali::DaliException e) {
31079       {
31080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31081       };
31082     } catch (...) {
31083       {
31084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31085       };
31086     }
31087   }
31088
31089   jresult = (void *)result;
31090   return jresult;
31091 }
31092
31093
31094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
31095   void * jresult ;
31096   Dali::KeyEvent *result = 0 ;
31097
31098   {
31099     try {
31100       result = (Dali::KeyEvent *)new Dali::KeyEvent();
31101     } catch (std::out_of_range& e) {
31102       {
31103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31104       };
31105     } catch (std::exception& e) {
31106       {
31107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31108       };
31109     } catch (Dali::DaliException e) {
31110       {
31111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31112       };
31113     } catch (...) {
31114       {
31115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31116       };
31117     }
31118   }
31119
31120   jresult = (void *)result;
31121   return jresult;
31122 }
31123
31124
31125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
31126   void * jresult ;
31127   std::string *arg1 = 0 ;
31128   std::string *arg2 = 0 ;
31129   int arg3 ;
31130   int arg4 ;
31131   unsigned long arg5 ;
31132   Dali::KeyEvent::State *arg6 = 0 ;
31133   Dali::KeyEvent::State temp6 ;
31134   Dali::KeyEvent *result = 0 ;
31135
31136   if (!jarg1) {
31137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31138     return 0;
31139   }
31140   std::string arg1_str(jarg1);
31141   arg1 = &arg1_str;
31142   if (!jarg2) {
31143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31144     return 0;
31145   }
31146   std::string arg2_str(jarg2);
31147   arg2 = &arg2_str;
31148   arg3 = (int)jarg3;
31149   arg4 = (int)jarg4;
31150   arg5 = (unsigned long)jarg5;
31151   temp6 = (Dali::KeyEvent::State)jarg6;
31152   arg6 = &temp6;
31153   {
31154     try {
31155       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31156     } catch (std::out_of_range& e) {
31157       {
31158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31159       };
31160     } catch (std::exception& e) {
31161       {
31162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31163       };
31164     } catch (Dali::DaliException e) {
31165       {
31166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31167       };
31168     } catch (...) {
31169       {
31170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31171       };
31172     }
31173   }
31174
31175   jresult = (void *)result;
31176
31177   //argout typemap for const std::string&
31178
31179
31180   //argout typemap for const std::string&
31181
31182   return jresult;
31183 }
31184
31185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31186   void * jresult ;
31187   Dali::KeyEvent *arg1 = 0 ;
31188   Dali::KeyEvent *result = 0 ;
31189
31190   arg1 = (Dali::KeyEvent *)jarg1;
31191   if (!arg1) {
31192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31193     return 0;
31194   }
31195   {
31196     try {
31197       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31198     } catch (std::out_of_range& e) {
31199       {
31200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31201       };
31202     } catch (std::exception& e) {
31203       {
31204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31205       };
31206     } catch (Dali::DaliException e) {
31207       {
31208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31209       };
31210     } catch (...) {
31211       {
31212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31213       };
31214     }
31215   }
31216
31217   jresult = (void *)result;
31218   return jresult;
31219 }
31220
31221
31222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31223   void * jresult ;
31224   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31225   Dali::KeyEvent *arg2 = 0 ;
31226   Dali::KeyEvent *result = 0 ;
31227
31228   arg1 = (Dali::KeyEvent *)jarg1;
31229   arg2 = (Dali::KeyEvent *)jarg2;
31230   if (!arg2) {
31231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31232     return 0;
31233   }
31234   {
31235     try {
31236       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31237     } catch (std::out_of_range& e) {
31238       {
31239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31240       };
31241     } catch (std::exception& e) {
31242       {
31243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31244       };
31245     } catch (Dali::DaliException e) {
31246       {
31247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31248       };
31249     } catch (...) {
31250       {
31251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31252       };
31253     }
31254   }
31255
31256   jresult = (void *)result;
31257   return jresult;
31258 }
31259
31260
31261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31262   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31263
31264   arg1 = (Dali::KeyEvent *)jarg1;
31265   {
31266     try {
31267       delete arg1;
31268     } catch (std::out_of_range& e) {
31269       {
31270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31271       };
31272     } catch (std::exception& e) {
31273       {
31274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31275       };
31276     } catch (Dali::DaliException e) {
31277       {
31278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31279       };
31280     } catch (...) {
31281       {
31282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31283       };
31284     }
31285   }
31286
31287 }
31288
31289
31290 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31291   unsigned int jresult ;
31292   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31293   bool result;
31294
31295   arg1 = (Dali::KeyEvent *)jarg1;
31296   {
31297     try {
31298       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31299     } catch (std::out_of_range& e) {
31300       {
31301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31302       };
31303     } catch (std::exception& e) {
31304       {
31305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31306       };
31307     } catch (Dali::DaliException e) {
31308       {
31309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31310       };
31311     } catch (...) {
31312       {
31313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31314       };
31315     }
31316   }
31317
31318   jresult = result;
31319   return jresult;
31320 }
31321
31322
31323 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31324   unsigned int jresult ;
31325   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31326   bool result;
31327
31328   arg1 = (Dali::KeyEvent *)jarg1;
31329   {
31330     try {
31331       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31332     } catch (std::out_of_range& e) {
31333       {
31334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31335       };
31336     } catch (std::exception& e) {
31337       {
31338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31339       };
31340     } catch (Dali::DaliException e) {
31341       {
31342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31343       };
31344     } catch (...) {
31345       {
31346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31347       };
31348     }
31349   }
31350
31351   jresult = result;
31352   return jresult;
31353 }
31354
31355
31356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31357   unsigned int jresult ;
31358   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31359   bool result;
31360
31361   arg1 = (Dali::KeyEvent *)jarg1;
31362   {
31363     try {
31364       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31365     } catch (std::out_of_range& e) {
31366       {
31367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31368       };
31369     } catch (std::exception& e) {
31370       {
31371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31372       };
31373     } catch (Dali::DaliException e) {
31374       {
31375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31376       };
31377     } catch (...) {
31378       {
31379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31380       };
31381     }
31382   }
31383
31384   jresult = result;
31385   return jresult;
31386 }
31387
31388
31389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31390   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31391   std::string *arg2 = 0 ;
31392
31393   arg1 = (Dali::KeyEvent *)jarg1;
31394   if (!jarg2) {
31395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31396     return ;
31397   }
31398   std::string arg2_str(jarg2);
31399   arg2 = &arg2_str;
31400   if (arg1) (arg1)->keyPressedName = *arg2;
31401
31402   //argout typemap for const std::string&
31403
31404 }
31405
31406
31407 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31408   char * jresult ;
31409
31410   if( jarg1 == NULL )
31411   {
31412     jresult = SWIG_csharp_string_callback( "" );
31413   }
31414   else
31415   {
31416     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31417     std::string *result = 0;
31418
31419     arg1 = ( Dali::KeyEvent * )jarg1;
31420     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31421     jresult = SWIG_csharp_string_callback( result->c_str() );
31422   }
31423
31424   return jresult;
31425 }
31426
31427
31428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31429   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31430   std::string *arg2 = 0 ;
31431
31432   arg1 = (Dali::KeyEvent *)jarg1;
31433   if (!jarg2) {
31434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31435     return ;
31436   }
31437   std::string arg2_str(jarg2);
31438   arg2 = &arg2_str;
31439   if (arg1) (arg1)->keyPressed = *arg2;
31440
31441   //argout typemap for const std::string&
31442
31443 }
31444
31445
31446 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31447   char * jresult ;
31448   if( NULL == jarg1 )
31449   {
31450     jresult = SWIG_csharp_string_callback( "" );
31451   }
31452   else
31453   {
31454     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31455     std::string *result = 0;
31456
31457     arg1 = ( Dali::KeyEvent * )jarg1;
31458     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31459     jresult = SWIG_csharp_string_callback( result->c_str() );
31460   }
31461   return jresult;
31462 }
31463
31464
31465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31466   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31467   int arg2 ;
31468
31469   arg1 = (Dali::KeyEvent *)jarg1;
31470   arg2 = (int)jarg2;
31471   if (arg1) (arg1)->keyCode = arg2;
31472 }
31473
31474
31475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31476   int jresult ;
31477   if( NULL == jarg1 )
31478   {
31479     jresult = -1;
31480   }
31481   else
31482   {
31483     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31484     int result;
31485
31486     arg1 = ( Dali::KeyEvent * )jarg1;
31487     result = (int)( ( arg1 )->keyCode );
31488     jresult = result;
31489   }
31490   return jresult;
31491 }
31492
31493
31494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31495   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31496   int arg2 ;
31497
31498   arg1 = (Dali::KeyEvent *)jarg1;
31499   arg2 = (int)jarg2;
31500   if (arg1) (arg1)->keyModifier = arg2;
31501 }
31502
31503
31504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31505   int jresult ;
31506   if( jarg1 == NULL )
31507   {
31508     jresult = -1;
31509   }
31510   else
31511   {
31512     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31513     int result;
31514
31515     arg1 = ( Dali::KeyEvent * )jarg1;
31516     result = (int)( ( arg1 )->keyModifier );
31517     jresult = result;
31518   }
31519   return jresult;
31520 }
31521
31522
31523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31524   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31525   unsigned long arg2 ;
31526
31527   arg1 = (Dali::KeyEvent *)jarg1;
31528   arg2 = (unsigned long)jarg2;
31529   if (arg1) (arg1)->time = arg2;
31530 }
31531
31532
31533 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31534   unsigned long jresult ;
31535   if( jarg1 == NULL )
31536   {
31537     jresult = 0;
31538   }
31539   else
31540   {
31541     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31542     unsigned long result;
31543
31544     arg1 = ( Dali::KeyEvent * )jarg1;
31545     result = (unsigned long)( ( arg1 )->time );
31546     jresult = (unsigned long)result;
31547   }
31548   return jresult;
31549 }
31550
31551
31552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31553   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31554   Dali::KeyEvent::State arg2 ;
31555
31556   arg1 = (Dali::KeyEvent *)jarg1;
31557   arg2 = (Dali::KeyEvent::State)jarg2;
31558   if (arg1) (arg1)->state = arg2;
31559 }
31560
31561
31562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31563   int jresult ;
31564   if( jarg1 == NULL )
31565   {
31566     jresult = -1;
31567   }
31568   else
31569   {
31570     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31571     Dali::KeyEvent::State result;
31572
31573     arg1 = ( Dali::KeyEvent * )jarg1;
31574     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31575     jresult = (int)result;
31576   }
31577   return jresult;
31578 }
31579
31580 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31581   char * jresult ;
31582   std::string result;
31583   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0;
31584
31585   arg1 = (Dali::KeyEvent *)jarg1;
31586   if (!arg1) {
31587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelKeyEvent const & type is null", 0);
31588     return 0;
31589   }
31590   {
31591     try {
31592       result = Dali::DevelKeyEvent::GetLogicalKey(*arg1);
31593     } catch (std::out_of_range& e) {
31594       {
31595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31596       };
31597     } catch (std::exception& e) {
31598       {
31599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31600       };
31601     } catch (Dali::DaliException e) {
31602       {
31603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31604       };
31605     } catch (...) {
31606       {
31607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31608       };
31609     }
31610
31611   }
31612
31613   jresult = SWIG_csharp_string_callback( (&result)->c_str() );
31614   return jresult;
31615 }
31616
31617
31618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31619   void * jresult ;
31620   Dali::LongPressGestureDetector *result = 0 ;
31621
31622   {
31623     try {
31624       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31625     } catch (std::out_of_range& e) {
31626       {
31627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31628       };
31629     } catch (std::exception& e) {
31630       {
31631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31632       };
31633     } catch (Dali::DaliException e) {
31634       {
31635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31636       };
31637     } catch (...) {
31638       {
31639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31640       };
31641     }
31642   }
31643
31644   jresult = (void *)result;
31645   return jresult;
31646 }
31647
31648
31649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31650   void * jresult ;
31651   Dali::LongPressGestureDetector result;
31652
31653   {
31654     try {
31655       result = Dali::LongPressGestureDetector::New();
31656     } catch (std::out_of_range& e) {
31657       {
31658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31659       };
31660     } catch (std::exception& e) {
31661       {
31662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31663       };
31664     } catch (Dali::DaliException e) {
31665       {
31666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31667       };
31668     } catch (...) {
31669       {
31670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31671       };
31672     }
31673   }
31674
31675   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31676   return jresult;
31677 }
31678
31679
31680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31681   void * jresult ;
31682   unsigned int arg1 ;
31683   Dali::LongPressGestureDetector result;
31684
31685   arg1 = (unsigned int)jarg1;
31686   {
31687     try {
31688       result = Dali::LongPressGestureDetector::New(arg1);
31689     } catch (std::out_of_range& e) {
31690       {
31691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31692       };
31693     } catch (std::exception& e) {
31694       {
31695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31696       };
31697     } catch (Dali::DaliException e) {
31698       {
31699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31700       };
31701     } catch (...) {
31702       {
31703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31704       };
31705     }
31706   }
31707
31708   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31709   return jresult;
31710 }
31711
31712
31713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31714   void * jresult ;
31715   unsigned int arg1 ;
31716   unsigned int arg2 ;
31717   Dali::LongPressGestureDetector result;
31718
31719   arg1 = (unsigned int)jarg1;
31720   arg2 = (unsigned int)jarg2;
31721   {
31722     try {
31723       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31724     } catch (std::out_of_range& e) {
31725       {
31726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31727       };
31728     } catch (std::exception& e) {
31729       {
31730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31731       };
31732     } catch (Dali::DaliException e) {
31733       {
31734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31735       };
31736     } catch (...) {
31737       {
31738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31739       };
31740     }
31741   }
31742
31743   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31744   return jresult;
31745 }
31746
31747
31748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31749   void * jresult ;
31750   Dali::BaseHandle arg1 ;
31751   Dali::BaseHandle *argp1 ;
31752   Dali::LongPressGestureDetector result;
31753
31754   argp1 = (Dali::BaseHandle *)jarg1;
31755   if (!argp1) {
31756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31757     return 0;
31758   }
31759   arg1 = *argp1;
31760   {
31761     try {
31762       result = Dali::LongPressGestureDetector::DownCast(arg1);
31763     } catch (std::out_of_range& e) {
31764       {
31765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31766       };
31767     } catch (std::exception& e) {
31768       {
31769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31770       };
31771     } catch (Dali::DaliException e) {
31772       {
31773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31774       };
31775     } catch (...) {
31776       {
31777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31778       };
31779     }
31780   }
31781
31782   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31783   return jresult;
31784 }
31785
31786
31787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31788   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31789
31790   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31791   {
31792     try {
31793       delete arg1;
31794     } catch (std::out_of_range& e) {
31795       {
31796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31797       };
31798     } catch (std::exception& e) {
31799       {
31800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31801       };
31802     } catch (Dali::DaliException e) {
31803       {
31804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31805       };
31806     } catch (...) {
31807       {
31808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31809       };
31810     }
31811   }
31812
31813 }
31814
31815
31816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31817   void * jresult ;
31818   Dali::LongPressGestureDetector *arg1 = 0 ;
31819   Dali::LongPressGestureDetector *result = 0 ;
31820
31821   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31822   if (!arg1) {
31823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31824     return 0;
31825   }
31826   {
31827     try {
31828       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31829     } catch (std::out_of_range& e) {
31830       {
31831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31832       };
31833     } catch (std::exception& e) {
31834       {
31835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31836       };
31837     } catch (Dali::DaliException e) {
31838       {
31839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31840       };
31841     } catch (...) {
31842       {
31843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31844       };
31845     }
31846   }
31847
31848   jresult = (void *)result;
31849   return jresult;
31850 }
31851
31852
31853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31854   void * jresult ;
31855   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31856   Dali::LongPressGestureDetector *arg2 = 0 ;
31857   Dali::LongPressGestureDetector *result = 0 ;
31858
31859   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31860   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31861   if (!arg2) {
31862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31863     return 0;
31864   }
31865   {
31866     try {
31867       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31868     } catch (std::out_of_range& e) {
31869       {
31870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31871       };
31872     } catch (std::exception& e) {
31873       {
31874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31875       };
31876     } catch (Dali::DaliException e) {
31877       {
31878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31879       };
31880     } catch (...) {
31881       {
31882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31883       };
31884     }
31885   }
31886
31887   jresult = (void *)result;
31888   return jresult;
31889 }
31890
31891
31892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31893   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31894   unsigned int arg2 ;
31895
31896   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31897   arg2 = (unsigned int)jarg2;
31898   {
31899     try {
31900       (arg1)->SetTouchesRequired(arg2);
31901     } catch (std::out_of_range& e) {
31902       {
31903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31904       };
31905     } catch (std::exception& e) {
31906       {
31907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31908       };
31909     } catch (Dali::DaliException e) {
31910       {
31911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31912       };
31913     } catch (...) {
31914       {
31915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31916       };
31917     }
31918   }
31919
31920 }
31921
31922
31923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31924   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31925   unsigned int arg2 ;
31926   unsigned int arg3 ;
31927
31928   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31929   arg2 = (unsigned int)jarg2;
31930   arg3 = (unsigned int)jarg3;
31931   {
31932     try {
31933       (arg1)->SetTouchesRequired(arg2,arg3);
31934     } catch (std::out_of_range& e) {
31935       {
31936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31937       };
31938     } catch (std::exception& e) {
31939       {
31940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31941       };
31942     } catch (Dali::DaliException e) {
31943       {
31944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31945       };
31946     } catch (...) {
31947       {
31948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31949       };
31950     }
31951   }
31952
31953 }
31954
31955
31956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31957   unsigned int jresult ;
31958   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31959   unsigned int result;
31960
31961   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31962   {
31963     try {
31964       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31965     } catch (std::out_of_range& e) {
31966       {
31967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31968       };
31969     } catch (std::exception& e) {
31970       {
31971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31972       };
31973     } catch (Dali::DaliException e) {
31974       {
31975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31976       };
31977     } catch (...) {
31978       {
31979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31980       };
31981     }
31982   }
31983
31984   jresult = result;
31985   return jresult;
31986 }
31987
31988
31989 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31990   unsigned int jresult ;
31991   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31992   unsigned int result;
31993
31994   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31995   {
31996     try {
31997       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31998     } catch (std::out_of_range& e) {
31999       {
32000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32001       };
32002     } catch (std::exception& e) {
32003       {
32004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32005       };
32006     } catch (Dali::DaliException e) {
32007       {
32008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32009       };
32010     } catch (...) {
32011       {
32012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32013       };
32014     }
32015   }
32016
32017   jresult = result;
32018   return jresult;
32019 }
32020
32021
32022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
32023   void * jresult ;
32024   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
32025   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
32026
32027   arg1 = (Dali::LongPressGestureDetector *)jarg1;
32028   {
32029     try {
32030       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
32031     } catch (std::out_of_range& e) {
32032       {
32033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32034       };
32035     } catch (std::exception& e) {
32036       {
32037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32038       };
32039     } catch (Dali::DaliException e) {
32040       {
32041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32042       };
32043     } catch (...) {
32044       {
32045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32046       };
32047     }
32048   }
32049
32050   jresult = (void *)result;
32051   return jresult;
32052 }
32053
32054
32055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
32056   void * jresult ;
32057   Dali::Gesture::State arg1 ;
32058   Dali::LongPressGesture *result = 0 ;
32059
32060   arg1 = (Dali::Gesture::State)jarg1;
32061   {
32062     try {
32063       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
32064     } catch (std::out_of_range& e) {
32065       {
32066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32067       };
32068     } catch (std::exception& e) {
32069       {
32070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32071       };
32072     } catch (Dali::DaliException e) {
32073       {
32074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32075       };
32076     } catch (...) {
32077       {
32078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32079       };
32080     }
32081   }
32082
32083   jresult = (void *)result;
32084   return jresult;
32085 }
32086
32087
32088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
32089   void * jresult ;
32090   Dali::LongPressGesture *arg1 = 0 ;
32091   Dali::LongPressGesture *result = 0 ;
32092
32093   arg1 = (Dali::LongPressGesture *)jarg1;
32094   if (!arg1) {
32095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32096     return 0;
32097   }
32098   {
32099     try {
32100       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
32101     } catch (std::out_of_range& e) {
32102       {
32103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32104       };
32105     } catch (std::exception& e) {
32106       {
32107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32108       };
32109     } catch (Dali::DaliException e) {
32110       {
32111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32112       };
32113     } catch (...) {
32114       {
32115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32116       };
32117     }
32118   }
32119
32120   jresult = (void *)result;
32121   return jresult;
32122 }
32123
32124
32125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
32126   void * jresult ;
32127   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32128   Dali::LongPressGesture *arg2 = 0 ;
32129   Dali::LongPressGesture *result = 0 ;
32130
32131   arg1 = (Dali::LongPressGesture *)jarg1;
32132   arg2 = (Dali::LongPressGesture *)jarg2;
32133   if (!arg2) {
32134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32135     return 0;
32136   }
32137   {
32138     try {
32139       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
32140     } catch (std::out_of_range& e) {
32141       {
32142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32143       };
32144     } catch (std::exception& e) {
32145       {
32146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32147       };
32148     } catch (Dali::DaliException e) {
32149       {
32150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32151       };
32152     } catch (...) {
32153       {
32154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32155       };
32156     }
32157   }
32158
32159   jresult = (void *)result;
32160   return jresult;
32161 }
32162
32163
32164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
32165   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32166
32167   arg1 = (Dali::LongPressGesture *)jarg1;
32168   {
32169     try {
32170       delete arg1;
32171     } catch (std::out_of_range& e) {
32172       {
32173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32174       };
32175     } catch (std::exception& e) {
32176       {
32177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32178       };
32179     } catch (Dali::DaliException e) {
32180       {
32181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32182       };
32183     } catch (...) {
32184       {
32185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32186       };
32187     }
32188   }
32189
32190 }
32191
32192
32193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32194   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32195   unsigned int arg2 ;
32196
32197   arg1 = (Dali::LongPressGesture *)jarg1;
32198   arg2 = (unsigned int)jarg2;
32199   if (arg1) (arg1)->numberOfTouches = arg2;
32200 }
32201
32202
32203 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32204   unsigned int jresult ;
32205   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32206   unsigned int result;
32207
32208   arg1 = (Dali::LongPressGesture *)jarg1;
32209   result = (unsigned int) ((arg1)->numberOfTouches);
32210   jresult = result;
32211   return jresult;
32212 }
32213
32214
32215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32216   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32217   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32218
32219   arg1 = (Dali::LongPressGesture *)jarg1;
32220   arg2 = (Dali::Vector2 *)jarg2;
32221   if (arg1) (arg1)->screenPoint = *arg2;
32222 }
32223
32224
32225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32226   void * jresult ;
32227   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32228   Dali::Vector2 *result = 0 ;
32229
32230   arg1 = (Dali::LongPressGesture *)jarg1;
32231   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32232   jresult = (void *)result;
32233   return jresult;
32234 }
32235
32236
32237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32238   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32239   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32240
32241   arg1 = (Dali::LongPressGesture *)jarg1;
32242   arg2 = (Dali::Vector2 *)jarg2;
32243   if (arg1) (arg1)->localPoint = *arg2;
32244 }
32245
32246
32247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32248   void * jresult ;
32249   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32250   Dali::Vector2 *result = 0 ;
32251
32252   arg1 = (Dali::LongPressGesture *)jarg1;
32253   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32254   jresult = (void *)result;
32255   return jresult;
32256 }
32257
32258
32259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32260   void * jresult ;
32261   Dali::WheelEvent *result = 0 ;
32262
32263   {
32264     try {
32265       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32266     } catch (std::out_of_range& e) {
32267       {
32268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32269       };
32270     } catch (std::exception& e) {
32271       {
32272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32273       };
32274     } catch (Dali::DaliException e) {
32275       {
32276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32277       };
32278     } catch (...) {
32279       {
32280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32281       };
32282     }
32283   }
32284
32285   jresult = (void *)result;
32286   return jresult;
32287 }
32288
32289
32290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32291   void * jresult ;
32292   Dali::WheelEvent::Type arg1 ;
32293   int arg2 ;
32294   unsigned int arg3 ;
32295   Dali::Vector2 arg4 ;
32296   int arg5 ;
32297   unsigned int arg6 ;
32298   Dali::Vector2 *argp4 ;
32299   Dali::WheelEvent *result = 0 ;
32300
32301   arg1 = (Dali::WheelEvent::Type)jarg1;
32302   arg2 = (int)jarg2;
32303   arg3 = (unsigned int)jarg3;
32304   argp4 = (Dali::Vector2 *)jarg4;
32305   if (!argp4) {
32306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32307     return 0;
32308   }
32309   arg4 = *argp4;
32310   arg5 = (int)jarg5;
32311   arg6 = (unsigned int)jarg6;
32312   {
32313     try {
32314       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32315     } catch (std::out_of_range& e) {
32316       {
32317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32318       };
32319     } catch (std::exception& e) {
32320       {
32321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32322       };
32323     } catch (Dali::DaliException e) {
32324       {
32325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32326       };
32327     } catch (...) {
32328       {
32329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32330       };
32331     }
32332   }
32333
32334   jresult = (void *)result;
32335   return jresult;
32336 }
32337
32338
32339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32340   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32341
32342   arg1 = (Dali::WheelEvent *)jarg1;
32343   {
32344     try {
32345       delete arg1;
32346     } catch (std::out_of_range& e) {
32347       {
32348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32349       };
32350     } catch (std::exception& e) {
32351       {
32352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32353       };
32354     } catch (Dali::DaliException e) {
32355       {
32356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32357       };
32358     } catch (...) {
32359       {
32360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32361       };
32362     }
32363   }
32364
32365 }
32366
32367
32368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32369   unsigned int jresult ;
32370   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32371   bool result;
32372
32373   arg1 = (Dali::WheelEvent *)jarg1;
32374   {
32375     try {
32376       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32377     } catch (std::out_of_range& e) {
32378       {
32379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32380       };
32381     } catch (std::exception& e) {
32382       {
32383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32384       };
32385     } catch (Dali::DaliException e) {
32386       {
32387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32388       };
32389     } catch (...) {
32390       {
32391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32392       };
32393     }
32394   }
32395
32396   jresult = result;
32397   return jresult;
32398 }
32399
32400
32401 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32402   unsigned int jresult ;
32403   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32404   bool result;
32405
32406   arg1 = (Dali::WheelEvent *)jarg1;
32407   {
32408     try {
32409       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32410     } catch (std::out_of_range& e) {
32411       {
32412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32413       };
32414     } catch (std::exception& e) {
32415       {
32416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32417       };
32418     } catch (Dali::DaliException e) {
32419       {
32420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32421       };
32422     } catch (...) {
32423       {
32424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32425       };
32426     }
32427   }
32428
32429   jresult = result;
32430   return jresult;
32431 }
32432
32433
32434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32435   unsigned int jresult ;
32436   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32437   bool result;
32438
32439   arg1 = (Dali::WheelEvent *)jarg1;
32440   {
32441     try {
32442       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32443     } catch (std::out_of_range& e) {
32444       {
32445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32446       };
32447     } catch (std::exception& e) {
32448       {
32449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32450       };
32451     } catch (Dali::DaliException e) {
32452       {
32453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32454       };
32455     } catch (...) {
32456       {
32457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32458       };
32459     }
32460   }
32461
32462   jresult = result;
32463   return jresult;
32464 }
32465
32466
32467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32468   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32469   Dali::WheelEvent::Type arg2 ;
32470
32471   arg1 = (Dali::WheelEvent *)jarg1;
32472   arg2 = (Dali::WheelEvent::Type)jarg2;
32473   if (arg1) (arg1)->type = arg2;
32474 }
32475
32476
32477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32478   int jresult ;
32479   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32480   Dali::WheelEvent::Type result;
32481
32482   arg1 = (Dali::WheelEvent *)jarg1;
32483   result = (Dali::WheelEvent::Type) ((arg1)->type);
32484   jresult = (int)result;
32485   return jresult;
32486 }
32487
32488
32489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32490   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32491   int arg2 ;
32492
32493   arg1 = (Dali::WheelEvent *)jarg1;
32494   arg2 = (int)jarg2;
32495   if (arg1) (arg1)->direction = arg2;
32496 }
32497
32498
32499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32500   int jresult ;
32501   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32502   int result;
32503
32504   arg1 = (Dali::WheelEvent *)jarg1;
32505   result = (int) ((arg1)->direction);
32506   jresult = result;
32507   return jresult;
32508 }
32509
32510
32511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32512   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32513   unsigned int arg2 ;
32514
32515   arg1 = (Dali::WheelEvent *)jarg1;
32516   arg2 = (unsigned int)jarg2;
32517   if (arg1) (arg1)->modifiers = arg2;
32518 }
32519
32520
32521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32522   unsigned int jresult ;
32523   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32524   unsigned int result;
32525
32526   arg1 = (Dali::WheelEvent *)jarg1;
32527   result = (unsigned int) ((arg1)->modifiers);
32528   jresult = result;
32529   return jresult;
32530 }
32531
32532
32533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32534   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32535   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32536
32537   arg1 = (Dali::WheelEvent *)jarg1;
32538   arg2 = (Dali::Vector2 *)jarg2;
32539   if (arg1) (arg1)->point = *arg2;
32540 }
32541
32542
32543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32544   void * jresult ;
32545   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32546   Dali::Vector2 *result = 0 ;
32547
32548   arg1 = (Dali::WheelEvent *)jarg1;
32549   result = (Dali::Vector2 *)& ((arg1)->point);
32550   jresult = (void *)result;
32551   return jresult;
32552 }
32553
32554
32555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32556   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32557   int arg2 ;
32558
32559   arg1 = (Dali::WheelEvent *)jarg1;
32560   arg2 = (int)jarg2;
32561   if (arg1) (arg1)->z = arg2;
32562 }
32563
32564
32565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32566   int jresult ;
32567   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32568   int result;
32569
32570   arg1 = (Dali::WheelEvent *)jarg1;
32571   result = (int) ((arg1)->z);
32572   jresult = result;
32573   return jresult;
32574 }
32575
32576
32577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32578   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32579   unsigned int arg2 ;
32580
32581   arg1 = (Dali::WheelEvent *)jarg1;
32582   arg2 = (unsigned int)jarg2;
32583   if (arg1) (arg1)->timeStamp = arg2;
32584 }
32585
32586
32587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32588   unsigned int jresult ;
32589   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32590   unsigned int result;
32591
32592   arg1 = (Dali::WheelEvent *)jarg1;
32593   result = (unsigned int) ((arg1)->timeStamp);
32594   jresult = result;
32595   return jresult;
32596 }
32597
32598 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32599   char * jresult ;
32600   Dali::KeyEvent *arg1 = 0 ;
32601   std::string 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 = arg1->GetDeviceName();
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 = SWIG_csharp_string_callback((&result)->c_str());
32631   return jresult;
32632 }
32633
32634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32635   int jresult ;
32636   Dali::KeyEvent *arg1 = 0 ;
32637   Dali::Device::Class::Type result;
32638
32639   arg1 = (Dali::KeyEvent *)jarg1;
32640   if (!arg1) {
32641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32642     return 0;
32643   }
32644   {
32645     try {
32646       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32647     } catch (std::out_of_range& e) {
32648       {
32649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32650       };
32651     } catch (std::exception& e) {
32652       {
32653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32654       };
32655     } catch (Dali::DaliException e) {
32656       {
32657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32658       };
32659     } catch (...) {
32660       {
32661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32662       };
32663     }
32664   }
32665
32666   jresult = (int)result;
32667   return jresult;
32668 }
32669
32670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32671   int jresult ;
32672   Dali::KeyEvent *arg1 = 0 ;
32673   Dali::Device::Subclass::Type result;
32674
32675   arg1 = (Dali::KeyEvent *)jarg1;
32676   if (!arg1) {
32677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32678     return 0;
32679   }
32680   {
32681     try {
32682       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32683     } catch (std::out_of_range& e) {
32684       {
32685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32686       };
32687     } catch (std::exception& e) {
32688       {
32689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32690       };
32691     } catch (Dali::DaliException e) {
32692       {
32693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32694       };
32695     } catch (...) {
32696       {
32697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32698       };
32699     }
32700   }
32701
32702   jresult = (int)result;
32703   return jresult;
32704 }
32705
32706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32707   Dali::Actor arg1 ;
32708   Dali::Actor *argp1 ;
32709
32710   argp1 = (Dali::Actor *)jarg1;
32711   if (!argp1) {
32712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32713     return ;
32714   }
32715   arg1 = *argp1;
32716   {
32717     try {
32718       arg1.Raise();
32719     } catch (std::out_of_range& e) {
32720       {
32721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32722       };
32723     } catch (std::exception& e) {
32724       {
32725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32726       };
32727     } catch (Dali::DaliException e) {
32728       {
32729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32730       };
32731     } catch (...) {
32732       {
32733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32734       };
32735     }
32736   }
32737
32738 }
32739
32740
32741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32742   Dali::Actor arg1 ;
32743   Dali::Actor *argp1 ;
32744
32745   argp1 = (Dali::Actor *)jarg1;
32746   if (!argp1) {
32747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32748     return ;
32749   }
32750   arg1 = *argp1;
32751   {
32752     try {
32753       arg1.Lower();
32754     } catch (std::out_of_range& e) {
32755       {
32756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32757       };
32758     } catch (std::exception& e) {
32759       {
32760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32761       };
32762     } catch (Dali::DaliException e) {
32763       {
32764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32765       };
32766     } catch (...) {
32767       {
32768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32769       };
32770     }
32771   }
32772
32773 }
32774
32775
32776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32777   Dali::Actor arg1 ;
32778   Dali::Actor *argp1 ;
32779
32780   argp1 = (Dali::Actor *)jarg1;
32781   if (!argp1) {
32782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32783     return ;
32784   }
32785   arg1 = *argp1;
32786   {
32787     try {
32788       arg1.RaiseToTop();
32789     } catch (std::out_of_range& e) {
32790       {
32791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32792       };
32793     } catch (std::exception& e) {
32794       {
32795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32796       };
32797     } catch (Dali::DaliException e) {
32798       {
32799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32800       };
32801     } catch (...) {
32802       {
32803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32804       };
32805     }
32806   }
32807
32808 }
32809
32810
32811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32812   Dali::Actor arg1 ;
32813   Dali::Actor *argp1 ;
32814
32815   argp1 = (Dali::Actor *)jarg1;
32816   if (!argp1) {
32817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32818     return ;
32819   }
32820   arg1 = *argp1;
32821   {
32822     try {
32823       arg1.LowerToBottom();
32824     } catch (std::out_of_range& e) {
32825       {
32826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32827       };
32828     } catch (std::exception& e) {
32829       {
32830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32831       };
32832     } catch (Dali::DaliException e) {
32833       {
32834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32835       };
32836     } catch (...) {
32837       {
32838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32839       };
32840     }
32841   }
32842
32843 }
32844
32845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32846   Dali::Actor arg1 ;
32847   Dali::Actor arg2 ;
32848   Dali::Actor *argp1 ;
32849   Dali::Actor *argp2 ;
32850
32851   argp1 = (Dali::Actor *)jarg1;
32852   if (!argp1) {
32853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32854     return ;
32855   }
32856   arg1 = *argp1;
32857   argp2 = (Dali::Actor *)jarg2;
32858   if (!argp2) {
32859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32860     return ;
32861   }
32862   arg2 = *argp2;
32863   {
32864     try {
32865       arg1.RaiseAbove(arg2);
32866     } catch (std::out_of_range& e) {
32867       {
32868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32869       };
32870     } catch (std::exception& e) {
32871       {
32872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32873       };
32874     } catch (Dali::DaliException e) {
32875       {
32876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32877       };
32878     } catch (...) {
32879       {
32880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32881       };
32882     }
32883   }
32884
32885 }
32886
32887
32888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32889   Dali::Actor arg1 ;
32890   Dali::Actor arg2 ;
32891   Dali::Actor *argp1 ;
32892   Dali::Actor *argp2 ;
32893
32894   argp1 = (Dali::Actor *)jarg1;
32895   if (!argp1) {
32896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32897     return ;
32898   }
32899   arg1 = *argp1;
32900   argp2 = (Dali::Actor *)jarg2;
32901   if (!argp2) {
32902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32903     return ;
32904   }
32905   arg2 = *argp2;
32906   {
32907     try {
32908       arg1.LowerBelow(arg2);
32909     } catch (std::out_of_range& e) {
32910       {
32911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32912       };
32913     } catch (std::exception& e) {
32914       {
32915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32916       };
32917     } catch (Dali::DaliException e) {
32918       {
32919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32920       };
32921     } catch (...) {
32922       {
32923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32924       };
32925     }
32926   }
32927
32928 }
32929
32930
32931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32932   void * jresult ;
32933   Dali::Actor arg1 ;
32934   Dali::Actor *argp1 ;
32935   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32936
32937   argp1 = (Dali::Actor *)jarg1;
32938   if (!argp1) {
32939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32940     return 0;
32941   }
32942   arg1 = *argp1;
32943   {
32944     try {
32945       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32946     } catch (std::out_of_range& e) {
32947       {
32948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32949       };
32950     } catch (std::exception& e) {
32951       {
32952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32953       };
32954     } catch (Dali::DaliException e) {
32955       {
32956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32957       };
32958     } catch (...) {
32959       {
32960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32961       };
32962     }
32963   }
32964
32965   jresult = (void *)result;
32966   return jresult;
32967 }
32968
32969
32970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32971   void * jresult ;
32972   Dali::Actor *arg1 ;
32973   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32974
32975   arg1 = (Dali::Actor *)jarg1;
32976   {
32977     try {
32978       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32979     } catch (std::out_of_range& e) {
32980       {
32981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32982       };
32983     } catch (std::exception& e) {
32984       {
32985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32986       };
32987     } catch (Dali::DaliException e) {
32988       {
32989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32990       };
32991     } catch (...) {
32992       {
32993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32994       };
32995     }
32996   }
32997
32998   jresult = (void *)result;
32999   return jresult;
33000 }
33001
33002
33003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
33004   int jresult ;
33005   int result;
33006
33007   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
33008   jresult = (int)result;
33009   return jresult;
33010 }
33011
33012
33013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
33014   int jresult ;
33015   int result;
33016
33017   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
33018   jresult = (int)result;
33019   return jresult;
33020 }
33021
33022
33023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
33024   int jresult ;
33025   int result;
33026
33027   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
33028   jresult = (int)result;
33029   return jresult;
33030 }
33031
33032
33033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
33034   int jresult ;
33035   int result;
33036
33037   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
33038   jresult = (int)result;
33039   return jresult;
33040 }
33041
33042
33043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
33044   int jresult ;
33045   int result;
33046
33047   result = (int)Dali::Actor::Property::ANCHOR_POINT;
33048   jresult = (int)result;
33049   return jresult;
33050 }
33051
33052
33053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
33054   int jresult ;
33055   int result;
33056
33057   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
33058   jresult = (int)result;
33059   return jresult;
33060 }
33061
33062
33063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
33064   int jresult ;
33065   int result;
33066
33067   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
33068   jresult = (int)result;
33069   return jresult;
33070 }
33071
33072
33073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
33074   int jresult ;
33075   int result;
33076
33077   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
33078   jresult = (int)result;
33079   return jresult;
33080 }
33081
33082
33083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
33084   int jresult ;
33085   int result;
33086
33087   result = (int)Dali::Actor::Property::SIZE;
33088   jresult = (int)result;
33089   return jresult;
33090 }
33091
33092
33093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
33094   int jresult ;
33095   int result;
33096
33097   result = (int)Dali::Actor::Property::SIZE_WIDTH;
33098   jresult = (int)result;
33099   return jresult;
33100 }
33101
33102
33103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
33104   int jresult ;
33105   int result;
33106
33107   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
33108   jresult = (int)result;
33109   return jresult;
33110 }
33111
33112
33113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
33114   int jresult ;
33115   int result;
33116
33117   result = (int)Dali::Actor::Property::SIZE_DEPTH;
33118   jresult = (int)result;
33119   return jresult;
33120 }
33121
33122
33123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
33124   int jresult ;
33125   int result;
33126
33127   result = (int)Dali::Actor::Property::POSITION;
33128   jresult = (int)result;
33129   return jresult;
33130 }
33131
33132
33133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
33134   int jresult ;
33135   int result;
33136
33137   result = (int)Dali::Actor::Property::POSITION_X;
33138   jresult = (int)result;
33139   return jresult;
33140 }
33141
33142
33143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
33144   int jresult ;
33145   int result;
33146
33147   result = (int)Dali::Actor::Property::POSITION_Y;
33148   jresult = (int)result;
33149   return jresult;
33150 }
33151
33152
33153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
33154   int jresult ;
33155   int result;
33156
33157   result = (int)Dali::Actor::Property::POSITION_Z;
33158   jresult = (int)result;
33159   return jresult;
33160 }
33161
33162
33163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33164   int jresult ;
33165   int result;
33166
33167   result = (int)Dali::Actor::Property::WORLD_POSITION;
33168   jresult = (int)result;
33169   return jresult;
33170 }
33171
33172
33173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33174   int jresult ;
33175   int result;
33176
33177   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33178   jresult = (int)result;
33179   return jresult;
33180 }
33181
33182
33183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33184   int jresult ;
33185   int result;
33186
33187   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33188   jresult = (int)result;
33189   return jresult;
33190 }
33191
33192
33193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33194   int jresult ;
33195   int result;
33196
33197   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33198   jresult = (int)result;
33199   return jresult;
33200 }
33201
33202
33203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33204   int jresult ;
33205   int result;
33206
33207   result = (int)Dali::Actor::Property::ORIENTATION;
33208   jresult = (int)result;
33209   return jresult;
33210 }
33211
33212
33213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33214   int jresult ;
33215   int result;
33216
33217   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33218   jresult = (int)result;
33219   return jresult;
33220 }
33221
33222
33223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33224   int jresult ;
33225   int result;
33226
33227   result = (int)Dali::Actor::Property::SCALE;
33228   jresult = (int)result;
33229   return jresult;
33230 }
33231
33232
33233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33234   int jresult ;
33235   int result;
33236
33237   result = (int)Dali::Actor::Property::SCALE_X;
33238   jresult = (int)result;
33239   return jresult;
33240 }
33241
33242
33243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33244   int jresult ;
33245   int result;
33246
33247   result = (int)Dali::Actor::Property::SCALE_Y;
33248   jresult = (int)result;
33249   return jresult;
33250 }
33251
33252
33253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33254   int jresult ;
33255   int result;
33256
33257   result = (int)Dali::Actor::Property::SCALE_Z;
33258   jresult = (int)result;
33259   return jresult;
33260 }
33261
33262
33263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33264   int jresult ;
33265   int result;
33266
33267   result = (int)Dali::Actor::Property::WORLD_SCALE;
33268   jresult = (int)result;
33269   return jresult;
33270 }
33271
33272
33273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33274   int jresult ;
33275   int result;
33276
33277   result = (int)Dali::Actor::Property::VISIBLE;
33278   jresult = (int)result;
33279   return jresult;
33280 }
33281
33282
33283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33284   int jresult ;
33285   int result;
33286
33287   result = (int)Dali::Actor::Property::COLOR;
33288   jresult = (int)result;
33289   return jresult;
33290 }
33291
33292
33293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33294   int jresult ;
33295   int result;
33296
33297   result = (int)Dali::Actor::Property::COLOR_RED;
33298   jresult = (int)result;
33299   return jresult;
33300 }
33301
33302
33303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33304   int jresult ;
33305   int result;
33306
33307   result = (int)Dali::Actor::Property::COLOR_GREEN;
33308   jresult = (int)result;
33309   return jresult;
33310 }
33311
33312
33313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33314   int jresult ;
33315   int result;
33316
33317   result = (int)Dali::Actor::Property::COLOR_BLUE;
33318   jresult = (int)result;
33319   return jresult;
33320 }
33321
33322
33323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33324   int jresult ;
33325   int result;
33326
33327   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33328   jresult = (int)result;
33329   return jresult;
33330 }
33331
33332
33333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33334   int jresult ;
33335   int result;
33336
33337   result = (int)Dali::Actor::Property::WORLD_COLOR;
33338   jresult = (int)result;
33339   return jresult;
33340 }
33341
33342
33343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33344   int jresult ;
33345   int result;
33346
33347   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33348   jresult = (int)result;
33349   return jresult;
33350 }
33351
33352
33353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33354   int jresult ;
33355   int result;
33356
33357   result = (int)Dali::Actor::Property::NAME;
33358   jresult = (int)result;
33359   return jresult;
33360 }
33361
33362
33363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33364   int jresult ;
33365   int result;
33366
33367   result = (int)Dali::Actor::Property::SENSITIVE;
33368   jresult = (int)result;
33369   return jresult;
33370 }
33371
33372
33373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33374   int jresult ;
33375   int result;
33376
33377   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33378   jresult = (int)result;
33379   return jresult;
33380 }
33381
33382
33383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33384   int jresult ;
33385   int result;
33386
33387   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33388   jresult = (int)result;
33389   return jresult;
33390 }
33391
33392
33393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33394   int jresult ;
33395   int result;
33396
33397   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33398   jresult = (int)result;
33399   return jresult;
33400 }
33401
33402
33403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33404   int jresult ;
33405   int result;
33406
33407   result = (int)Dali::Actor::Property::COLOR_MODE;
33408   jresult = (int)result;
33409   return jresult;
33410 }
33411
33412
33413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33414   int jresult ;
33415   int result;
33416
33417   result = (int)Dali::Actor::Property::DRAW_MODE;
33418   jresult = (int)result;
33419   return jresult;
33420 }
33421
33422
33423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33424   int jresult ;
33425   int result;
33426
33427   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33428   jresult = (int)result;
33429   return jresult;
33430 }
33431
33432
33433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33434   int jresult ;
33435   int result;
33436
33437   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33438   jresult = (int)result;
33439   return jresult;
33440 }
33441
33442
33443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33444   int jresult ;
33445   int result;
33446
33447   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33448   jresult = (int)result;
33449   return jresult;
33450 }
33451
33452
33453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33454   int jresult ;
33455   int result;
33456
33457   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33458   jresult = (int)result;
33459   return jresult;
33460 }
33461
33462
33463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33464   int jresult ;
33465   int result;
33466
33467   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33468   jresult = (int)result;
33469   return jresult;
33470 }
33471
33472
33473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33474   int jresult ;
33475   int result;
33476
33477   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33478   jresult = (int)result;
33479   return jresult;
33480 }
33481
33482
33483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33484   int jresult ;
33485   int result;
33486
33487   result = (int)Dali::Actor::Property::PADDING;
33488   jresult = (int)result;
33489   return jresult;
33490 }
33491
33492
33493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33494   int jresult ;
33495   int result;
33496
33497   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33498   jresult = (int)result;
33499   return jresult;
33500 }
33501
33502
33503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33504   int jresult ;
33505   int result;
33506
33507   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33508   jresult = (int)result;
33509   return jresult;
33510 }
33511
33512
33513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33514   int jresult ;
33515   int result;
33516
33517   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33518   jresult = (int)result;
33519   return jresult;
33520 }
33521
33522
33523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33524   int jresult ;
33525   int result;
33526
33527   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33528   jresult = (int)result;
33529   return jresult;
33530 }
33531
33532
33533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33534   void * jresult ;
33535   Dali::Actor::Property *result = 0 ;
33536
33537   {
33538     try {
33539       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33540     } catch (std::out_of_range& e) {
33541       {
33542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33543       };
33544     } catch (std::exception& e) {
33545       {
33546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33547       };
33548     } catch (Dali::DaliException e) {
33549       {
33550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33551       };
33552     } catch (...) {
33553       {
33554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33555       };
33556     }
33557   }
33558
33559   jresult = (void *)result;
33560   return jresult;
33561 }
33562
33563
33564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33565   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33566
33567   arg1 = (Dali::Actor::Property *)jarg1;
33568   {
33569     try {
33570       delete arg1;
33571     } catch (std::out_of_range& e) {
33572       {
33573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33574       };
33575     } catch (std::exception& e) {
33576       {
33577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33578       };
33579     } catch (Dali::DaliException e) {
33580       {
33581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33582       };
33583     } catch (...) {
33584       {
33585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33586       };
33587     }
33588   }
33589
33590 }
33591
33592
33593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33594   void * jresult ;
33595   Dali::Actor *result = 0 ;
33596
33597   {
33598     try {
33599       result = (Dali::Actor *)new Dali::Actor();
33600     } catch (std::out_of_range& e) {
33601       {
33602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33603       };
33604     } catch (std::exception& e) {
33605       {
33606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33607       };
33608     } catch (Dali::DaliException e) {
33609       {
33610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33611       };
33612     } catch (...) {
33613       {
33614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33615       };
33616     }
33617   }
33618
33619   jresult = (void *)result;
33620   return jresult;
33621 }
33622
33623
33624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33625   void * jresult ;
33626   Dali::Actor result;
33627
33628   {
33629     try {
33630       result = Dali::Actor::New();
33631     } catch (std::out_of_range& e) {
33632       {
33633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33634       };
33635     } catch (std::exception& e) {
33636       {
33637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33638       };
33639     } catch (Dali::DaliException e) {
33640       {
33641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33642       };
33643     } catch (...) {
33644       {
33645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33646       };
33647     }
33648   }
33649
33650   jresult = new Dali::Actor((const Dali::Actor &)result);
33651   return jresult;
33652 }
33653
33654
33655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33656   void * jresult ;
33657   Dali::BaseHandle arg1 ;
33658   Dali::BaseHandle *argp1 ;
33659   Dali::Actor result;
33660
33661   argp1 = (Dali::BaseHandle *)jarg1;
33662   if (!argp1) {
33663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33664     return 0;
33665   }
33666   arg1 = *argp1;
33667   {
33668     try {
33669       result = Dali::Actor::DownCast(arg1);
33670     } catch (std::out_of_range& e) {
33671       {
33672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33673       };
33674     } catch (std::exception& e) {
33675       {
33676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33677       };
33678     } catch (Dali::DaliException e) {
33679       {
33680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33681       };
33682     } catch (...) {
33683       {
33684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33685       };
33686     }
33687   }
33688
33689   jresult = new Dali::Actor((const Dali::Actor &)result);
33690   return jresult;
33691 }
33692
33693
33694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33695   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33696
33697   arg1 = (Dali::Actor *)jarg1;
33698   {
33699     try {
33700       delete arg1;
33701     } catch (std::out_of_range& e) {
33702       {
33703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33704       };
33705     } catch (std::exception& e) {
33706       {
33707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33708       };
33709     } catch (Dali::DaliException e) {
33710       {
33711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33712       };
33713     } catch (...) {
33714       {
33715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33716       };
33717     }
33718   }
33719
33720 }
33721
33722
33723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33724   void * jresult ;
33725   Dali::Actor *arg1 = 0 ;
33726   Dali::Actor *result = 0 ;
33727
33728   arg1 = (Dali::Actor *)jarg1;
33729   if (!arg1) {
33730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33731     return 0;
33732   }
33733   {
33734     try {
33735       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
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 = (void *)result;
33756   return jresult;
33757 }
33758
33759
33760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33761   void * jresult ;
33762   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33763   Dali::Actor *arg2 = 0 ;
33764   Dali::Actor *result = 0 ;
33765
33766   arg1 = (Dali::Actor *)jarg1;
33767   arg2 = (Dali::Actor *)jarg2;
33768   if (!arg2) {
33769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33770     return 0;
33771   }
33772   {
33773     try {
33774       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33775     } catch (std::out_of_range& e) {
33776       {
33777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33778       };
33779     } catch (std::exception& e) {
33780       {
33781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33782       };
33783     } catch (Dali::DaliException e) {
33784       {
33785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33786       };
33787     } catch (...) {
33788       {
33789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33790       };
33791     }
33792   }
33793
33794   jresult = (void *)result;
33795   return jresult;
33796 }
33797
33798
33799 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33800   char * jresult ;
33801   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33802   std::string *result = 0 ;
33803
33804   arg1 = (Dali::Actor *)jarg1;
33805   {
33806     try {
33807       std::string name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
33808       result = (std::string *) &name;
33809     } catch (std::out_of_range& e) {
33810       {
33811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33812       };
33813     } catch (std::exception& e) {
33814       {
33815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33816       };
33817     } catch (Dali::DaliException e) {
33818       {
33819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33820       };
33821     } catch (...) {
33822       {
33823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33824       };
33825     }
33826   }
33827
33828   jresult = SWIG_csharp_string_callback(result->c_str());
33829   return jresult;
33830 }
33831
33832
33833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33834   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33835   std::string *arg2 = 0 ;
33836
33837   arg1 = (Dali::Actor *)jarg1;
33838   if (!jarg2) {
33839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33840     return ;
33841   }
33842   std::string arg2_str(jarg2);
33843   arg2 = &arg2_str;
33844   {
33845     try {
33846       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
33847     } catch (std::out_of_range& e) {
33848       {
33849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33850       };
33851     } catch (std::exception& e) {
33852       {
33853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33854       };
33855     } catch (Dali::DaliException e) {
33856       {
33857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33858       };
33859     } catch (...) {
33860       {
33861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33862       };
33863     }
33864   }
33865
33866
33867   //argout typemap for const std::string&
33868
33869 }
33870
33871
33872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33873   unsigned int jresult ;
33874   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33875   unsigned int result;
33876
33877   arg1 = (Dali::Actor *)jarg1;
33878
33879   if(!arg1) {
33880     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
33881     return -1;
33882   }
33883
33884   {
33885     try {
33886       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33887     } catch (std::out_of_range& e) {
33888       {
33889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33890       };
33891     } catch (std::exception& e) {
33892       {
33893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33894       };
33895     } catch (Dali::DaliException e) {
33896       {
33897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33898       };
33899     } catch (...) {
33900       {
33901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33902       };
33903     }
33904   }
33905
33906   jresult = result;
33907   return jresult;
33908 }
33909
33910
33911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33912   unsigned int jresult ;
33913   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33914   bool result;
33915
33916   arg1 = (Dali::Actor *)jarg1;
33917   {
33918     try {
33919       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33920     } catch (std::out_of_range& e) {
33921       {
33922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33923       };
33924     } catch (std::exception& e) {
33925       {
33926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33927       };
33928     } catch (Dali::DaliException e) {
33929       {
33930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33931       };
33932     } catch (...) {
33933       {
33934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33935       };
33936     }
33937   }
33938
33939   jresult = result;
33940   return jresult;
33941 }
33942
33943
33944 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33945   unsigned int jresult ;
33946   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33947   bool result;
33948
33949   arg1 = (Dali::Actor *)jarg1;
33950   {
33951     try {
33952       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33953     } catch (std::out_of_range& e) {
33954       {
33955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33956       };
33957     } catch (std::exception& e) {
33958       {
33959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33960       };
33961     } catch (Dali::DaliException e) {
33962       {
33963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33964       };
33965     } catch (...) {
33966       {
33967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33968       };
33969     }
33970   }
33971
33972   jresult = result;
33973   return jresult;
33974 }
33975
33976
33977 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33978   unsigned int jresult ;
33979   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33980   bool result;
33981
33982   arg1 = (Dali::Actor *)jarg1;
33983   {
33984     try {
33985       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33986     } catch (std::out_of_range& e) {
33987       {
33988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33989       };
33990     } catch (std::exception& e) {
33991       {
33992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33993       };
33994     } catch (Dali::DaliException e) {
33995       {
33996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33997       };
33998     } catch (...) {
33999       {
34000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34001       };
34002     }
34003   }
34004
34005   jresult = result;
34006   return jresult;
34007 }
34008
34009
34010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
34011   void * jresult ;
34012   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34013   Dali::Layer result;
34014
34015   arg1 = (Dali::Actor *)jarg1;
34016   {
34017     try {
34018       result = (arg1)->GetLayer();
34019     } catch (std::out_of_range& e) {
34020       {
34021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34022       };
34023     } catch (std::exception& e) {
34024       {
34025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34026       };
34027     } catch (Dali::DaliException e) {
34028       {
34029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34030       };
34031     } catch (...) {
34032       {
34033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34034       };
34035     }
34036   }
34037
34038   jresult = new Dali::Layer((const Dali::Layer &)result);
34039   return jresult;
34040 }
34041
34042
34043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
34044   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34045   Dali::Actor arg2 ;
34046   Dali::Actor *argp2 ;
34047
34048   arg1 = (Dali::Actor *)jarg1;
34049   argp2 = (Dali::Actor *)jarg2;
34050   if (!argp2) {
34051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34052     return ;
34053   }
34054   arg2 = *argp2;
34055   {
34056     try {
34057       (arg1)->Add(arg2);
34058     } catch (std::out_of_range& e) {
34059       {
34060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34061       };
34062     } catch (std::exception& e) {
34063       {
34064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34065       };
34066     } catch (Dali::DaliException e) {
34067       {
34068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34069       };
34070     } catch (...) {
34071       {
34072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34073       };
34074     }
34075   }
34076
34077 }
34078
34079
34080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
34081   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34082   Dali::Actor arg2 ;
34083   Dali::Actor *argp2 ;
34084
34085   arg1 = (Dali::Actor *)jarg1;
34086   argp2 = (Dali::Actor *)jarg2;
34087   if (!argp2) {
34088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34089     return ;
34090   }
34091   arg2 = *argp2;
34092   {
34093     try {
34094       (arg1)->Remove(arg2);
34095     } catch (std::out_of_range& e) {
34096       {
34097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34098       };
34099     } catch (std::exception& e) {
34100       {
34101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34102       };
34103     } catch (Dali::DaliException e) {
34104       {
34105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34106       };
34107     } catch (...) {
34108       {
34109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34110       };
34111     }
34112   }
34113
34114 }
34115
34116
34117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
34118   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34119
34120   arg1 = (Dali::Actor *)jarg1;
34121   {
34122     try {
34123       (arg1)->Unparent();
34124     } catch (std::out_of_range& e) {
34125       {
34126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34127       };
34128     } catch (std::exception& e) {
34129       {
34130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34131       };
34132     } catch (Dali::DaliException e) {
34133       {
34134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34135       };
34136     } catch (...) {
34137       {
34138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34139       };
34140     }
34141   }
34142
34143 }
34144
34145
34146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
34147   unsigned int jresult ;
34148   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34149   unsigned int result;
34150
34151   arg1 = (Dali::Actor *)jarg1;
34152   {
34153     try {
34154       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
34155     } catch (std::out_of_range& e) {
34156       {
34157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34158       };
34159     } catch (std::exception& e) {
34160       {
34161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34162       };
34163     } catch (Dali::DaliException e) {
34164       {
34165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34166       };
34167     } catch (...) {
34168       {
34169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34170       };
34171     }
34172   }
34173
34174   jresult = result;
34175   return jresult;
34176 }
34177
34178
34179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34180   void * jresult ;
34181   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34182   unsigned int arg2 ;
34183   Dali::Actor result;
34184
34185   arg1 = (Dali::Actor *)jarg1;
34186   arg2 = (unsigned int)jarg2;
34187   {
34188     try {
34189       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34190     } catch (std::out_of_range& e) {
34191       {
34192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34193       };
34194     } catch (std::exception& e) {
34195       {
34196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34197       };
34198     } catch (Dali::DaliException e) {
34199       {
34200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34201       };
34202     } catch (...) {
34203       {
34204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34205       };
34206     }
34207   }
34208
34209   jresult = new Dali::Actor((const Dali::Actor &)result);
34210   return jresult;
34211 }
34212
34213
34214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34215   void * jresult ;
34216   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34217   std::string *arg2 = 0 ;
34218   Dali::Actor result;
34219
34220   arg1 = (Dali::Actor *)jarg1;
34221   if (!jarg2) {
34222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34223     return 0;
34224   }
34225   std::string arg2_str(jarg2);
34226   arg2 = &arg2_str;
34227   {
34228     try {
34229       result = (arg1)->FindChildByName((std::string const &)*arg2);
34230     } catch (std::out_of_range& e) {
34231       {
34232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34233       };
34234     } catch (std::exception& e) {
34235       {
34236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34237       };
34238     } catch (Dali::DaliException e) {
34239       {
34240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34241       };
34242     } catch (...) {
34243       {
34244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34245       };
34246     }
34247   }
34248
34249   jresult = new Dali::Actor((const Dali::Actor &)result);
34250
34251   //argout typemap for const std::string&
34252
34253   return jresult;
34254 }
34255
34256
34257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34258   void * jresult ;
34259   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34260   unsigned int arg2 ;
34261   Dali::Actor result;
34262
34263   arg1 = (Dali::Actor *)jarg1;
34264   arg2 = (unsigned int)jarg2;
34265   {
34266     try {
34267       result = (arg1)->FindChildById(arg2);
34268     } catch (std::out_of_range& e) {
34269       {
34270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34271       };
34272     } catch (std::exception& e) {
34273       {
34274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34275       };
34276     } catch (Dali::DaliException e) {
34277       {
34278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34279       };
34280     } catch (...) {
34281       {
34282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34283       };
34284     }
34285   }
34286
34287   jresult = new Dali::Actor((const Dali::Actor &)result);
34288   return jresult;
34289 }
34290
34291
34292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34293   void * jresult ;
34294   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34295   Dali::Actor result;
34296
34297   arg1 = (Dali::Actor *)jarg1;
34298   {
34299     try {
34300       result = ((Dali::Actor const *)arg1)->GetParent();
34301     } catch (std::out_of_range& e) {
34302       {
34303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34304       };
34305     } catch (std::exception& e) {
34306       {
34307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34308       };
34309     } catch (Dali::DaliException e) {
34310       {
34311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34312       };
34313     } catch (...) {
34314       {
34315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34316       };
34317     }
34318   }
34319
34320   jresult = new Dali::Actor((const Dali::Actor &)result);
34321   return jresult;
34322 }
34323
34324
34325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34326   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34327   Dali::Vector3 *arg2 = 0 ;
34328
34329   arg1 = (Dali::Actor *)jarg1;
34330   arg2 = (Dali::Vector3 *)jarg2;
34331   if (!arg2) {
34332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34333     return ;
34334   }
34335   {
34336     try {
34337       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
34338     } catch (std::out_of_range& e) {
34339       {
34340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34341       };
34342     } catch (std::exception& e) {
34343       {
34344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34345       };
34346     } catch (Dali::DaliException e) {
34347       {
34348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34349       };
34350     } catch (...) {
34351       {
34352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34353       };
34354     }
34355   }
34356
34357 }
34358
34359
34360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34361   void * jresult ;
34362   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34363   Dali::Vector3 result;
34364
34365   arg1 = (Dali::Actor *)jarg1;
34366   {
34367     try {
34368       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
34369     } catch (std::out_of_range& e) {
34370       {
34371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34372       };
34373     } catch (std::exception& e) {
34374       {
34375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34376       };
34377     } catch (Dali::DaliException e) {
34378       {
34379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34380       };
34381     } catch (...) {
34382       {
34383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34384       };
34385     }
34386   }
34387
34388   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34389   return jresult;
34390 }
34391
34392
34393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34394   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34395   Dali::Vector3 *arg2 = 0 ;
34396
34397   arg1 = (Dali::Actor *)jarg1;
34398   arg2 = (Dali::Vector3 *)jarg2;
34399   if (!arg2) {
34400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34401     return ;
34402   }
34403   {
34404     try {
34405       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
34406     } catch (std::out_of_range& e) {
34407       {
34408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34409       };
34410     } catch (std::exception& e) {
34411       {
34412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34413       };
34414     } catch (Dali::DaliException e) {
34415       {
34416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34417       };
34418     } catch (...) {
34419       {
34420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34421       };
34422     }
34423   }
34424
34425 }
34426
34427
34428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34429   void * jresult ;
34430   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34431   Dali::Vector3 result;
34432
34433   arg1 = (Dali::Actor *)jarg1;
34434   {
34435     try {
34436       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
34437     } catch (std::out_of_range& e) {
34438       {
34439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34440       };
34441     } catch (std::exception& e) {
34442       {
34443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34444       };
34445     } catch (Dali::DaliException e) {
34446       {
34447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34448       };
34449     } catch (...) {
34450       {
34451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34452       };
34453     }
34454   }
34455
34456   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34457   return jresult;
34458 }
34459
34460
34461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34462   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34463   float arg2 ;
34464   float arg3 ;
34465
34466   arg1 = (Dali::Actor *)jarg1;
34467   arg2 = (float)jarg2;
34468   arg3 = (float)jarg3;
34469   {
34470     try {
34471       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
34472     } catch (std::out_of_range& e) {
34473       {
34474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34475       };
34476     } catch (std::exception& e) {
34477       {
34478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34479       };
34480     } catch (Dali::DaliException e) {
34481       {
34482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34483       };
34484     } catch (...) {
34485       {
34486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34487       };
34488     }
34489   }
34490
34491 }
34492
34493
34494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34495   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34496   float arg2 ;
34497   float arg3 ;
34498   float arg4 ;
34499
34500   arg1 = (Dali::Actor *)jarg1;
34501   arg2 = (float)jarg2;
34502   arg3 = (float)jarg3;
34503   arg4 = (float)jarg4;
34504   {
34505     try {
34506       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
34507     } catch (std::out_of_range& e) {
34508       {
34509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34510       };
34511     } catch (std::exception& e) {
34512       {
34513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34514       };
34515     } catch (Dali::DaliException e) {
34516       {
34517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34518       };
34519     } catch (...) {
34520       {
34521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34522       };
34523     }
34524   }
34525
34526 }
34527
34528
34529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34530   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34531   Dali::Vector2 *arg2 = 0 ;
34532
34533   arg1 = (Dali::Actor *)jarg1;
34534   arg2 = (Dali::Vector2 *)jarg2;
34535   if (!arg2) {
34536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34537     return ;
34538   }
34539   {
34540     try {
34541       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
34542     } catch (std::out_of_range& e) {
34543       {
34544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34545       };
34546     } catch (std::exception& e) {
34547       {
34548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34549       };
34550     } catch (Dali::DaliException e) {
34551       {
34552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34553       };
34554     } catch (...) {
34555       {
34556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34557       };
34558     }
34559   }
34560
34561 }
34562
34563
34564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34565   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34566   Dali::Vector3 *arg2 = 0 ;
34567
34568   arg1 = (Dali::Actor *)jarg1;
34569   arg2 = (Dali::Vector3 *)jarg2;
34570   if (!arg2) {
34571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34572     return ;
34573   }
34574   {
34575     try {
34576       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
34577     } catch (std::out_of_range& e) {
34578       {
34579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34580       };
34581     } catch (std::exception& e) {
34582       {
34583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34584       };
34585     } catch (Dali::DaliException e) {
34586       {
34587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34588       };
34589     } catch (...) {
34590       {
34591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34592       };
34593     }
34594   }
34595
34596 }
34597
34598
34599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34600   void * jresult ;
34601   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34602   Dali::Vector3 result;
34603
34604   arg1 = (Dali::Actor *)jarg1;
34605   {
34606     try {
34607       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34608     } catch (std::out_of_range& e) {
34609       {
34610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34611       };
34612     } catch (std::exception& e) {
34613       {
34614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34615       };
34616     } catch (Dali::DaliException e) {
34617       {
34618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34619       };
34620     } catch (...) {
34621       {
34622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34623       };
34624     }
34625   }
34626
34627   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34628   return jresult;
34629 }
34630
34631
34632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34633   void * jresult ;
34634   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34635   Dali::Vector3 result;
34636
34637   arg1 = (Dali::Actor *)jarg1;
34638   {
34639     try {
34640       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
34641     } catch (std::out_of_range& e) {
34642       {
34643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34644       };
34645     } catch (std::exception& e) {
34646       {
34647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34648       };
34649     } catch (Dali::DaliException e) {
34650       {
34651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34652       };
34653     } catch (...) {
34654       {
34655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34656       };
34657     }
34658   }
34659
34660   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34661   return jresult;
34662 }
34663
34664
34665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34666   void * jresult ;
34667   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34668   Dali::Vector3 result;
34669
34670   arg1 = (Dali::Actor *)jarg1;
34671   {
34672     try {
34673       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34674     } catch (std::out_of_range& e) {
34675       {
34676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34677       };
34678     } catch (std::exception& e) {
34679       {
34680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34681       };
34682     } catch (Dali::DaliException e) {
34683       {
34684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34685       };
34686     } catch (...) {
34687       {
34688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34689       };
34690     }
34691   }
34692
34693   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34694   return jresult;
34695 }
34696
34697
34698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34699   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34700   float arg2 ;
34701   float arg3 ;
34702
34703   arg1 = (Dali::Actor *)jarg1;
34704   arg2 = (float)jarg2;
34705   arg3 = (float)jarg3;
34706   {
34707     try {
34708       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
34709     } catch (std::out_of_range& e) {
34710       {
34711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34712       };
34713     } catch (std::exception& e) {
34714       {
34715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34716       };
34717     } catch (Dali::DaliException e) {
34718       {
34719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34720       };
34721     } catch (...) {
34722       {
34723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34724       };
34725     }
34726   }
34727
34728 }
34729
34730
34731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34732   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34733   float arg2 ;
34734   float arg3 ;
34735   float arg4 ;
34736
34737   arg1 = (Dali::Actor *)jarg1;
34738   arg2 = (float)jarg2;
34739   arg3 = (float)jarg3;
34740   arg4 = (float)jarg4;
34741   {
34742     try {
34743       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
34744     } catch (std::out_of_range& e) {
34745       {
34746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34747       };
34748     } catch (std::exception& e) {
34749       {
34750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34751       };
34752     } catch (Dali::DaliException e) {
34753       {
34754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34755       };
34756     } catch (...) {
34757       {
34758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34759       };
34760     }
34761   }
34762
34763 }
34764
34765
34766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34767   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34768   Dali::Vector3 *arg2 = 0 ;
34769
34770   arg1 = (Dali::Actor *)jarg1;
34771   arg2 = (Dali::Vector3 *)jarg2;
34772   if (!arg2) {
34773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34774     return ;
34775   }
34776   {
34777     try {
34778       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
34779     } catch (std::out_of_range& e) {
34780       {
34781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34782       };
34783     } catch (std::exception& e) {
34784       {
34785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34786       };
34787     } catch (Dali::DaliException e) {
34788       {
34789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34790       };
34791     } catch (...) {
34792       {
34793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34794       };
34795     }
34796   }
34797
34798 }
34799
34800
34801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34802   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34803   float arg2 ;
34804
34805   arg1 = (Dali::Actor *)jarg1;
34806   arg2 = (float)jarg2;
34807   {
34808     try {
34809       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
34810     } catch (std::out_of_range& e) {
34811       {
34812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34813       };
34814     } catch (std::exception& e) {
34815       {
34816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34817       };
34818     } catch (Dali::DaliException e) {
34819       {
34820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34821       };
34822     } catch (...) {
34823       {
34824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34825       };
34826     }
34827   }
34828
34829 }
34830
34831
34832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34833   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34834   float arg2 ;
34835
34836   arg1 = (Dali::Actor *)jarg1;
34837   arg2 = (float)jarg2;
34838   {
34839     try {
34840       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
34841     } catch (std::out_of_range& e) {
34842       {
34843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34844       };
34845     } catch (std::exception& e) {
34846       {
34847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34848       };
34849     } catch (Dali::DaliException e) {
34850       {
34851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34852       };
34853     } catch (...) {
34854       {
34855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34856       };
34857     }
34858   }
34859
34860 }
34861
34862
34863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34864   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34865   float arg2 ;
34866
34867   arg1 = (Dali::Actor *)jarg1;
34868   arg2 = (float)jarg2;
34869   {
34870     try {
34871       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
34872     } catch (std::out_of_range& e) {
34873       {
34874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34875       };
34876     } catch (std::exception& e) {
34877       {
34878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34879       };
34880     } catch (Dali::DaliException e) {
34881       {
34882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34883       };
34884     } catch (...) {
34885       {
34886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34887       };
34888     }
34889   }
34890
34891 }
34892
34893
34894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34895   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34896   Dali::Vector3 *arg2 = 0 ;
34897
34898   arg1 = (Dali::Actor *)jarg1;
34899   arg2 = (Dali::Vector3 *)jarg2;
34900   if (!arg2) {
34901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34902     return ;
34903   }
34904   {
34905     try {
34906       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34907     } catch (std::out_of_range& e) {
34908       {
34909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34910       };
34911     } catch (std::exception& e) {
34912       {
34913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34914       };
34915     } catch (Dali::DaliException e) {
34916       {
34917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34918       };
34919     } catch (...) {
34920       {
34921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34922       };
34923     }
34924   }
34925
34926 }
34927
34928
34929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34930   void * jresult ;
34931   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34932   Dali::Vector3 result;
34933
34934   arg1 = (Dali::Actor *)jarg1;
34935   {
34936     try {
34937       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
34938     } catch (std::out_of_range& e) {
34939       {
34940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34941       };
34942     } catch (std::exception& e) {
34943       {
34944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34945       };
34946     } catch (Dali::DaliException e) {
34947       {
34948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34949       };
34950     } catch (...) {
34951       {
34952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34953       };
34954     }
34955   }
34956
34957   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34958   return jresult;
34959 }
34960
34961
34962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34963   void * jresult ;
34964   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34965   Dali::Vector3 result;
34966
34967   arg1 = (Dali::Actor *)jarg1;
34968   {
34969     try {
34970       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
34971     } catch (std::out_of_range& e) {
34972       {
34973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34974       };
34975     } catch (std::exception& e) {
34976       {
34977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34978       };
34979     } catch (Dali::DaliException e) {
34980       {
34981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34982       };
34983     } catch (...) {
34984       {
34985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34986       };
34987     }
34988   }
34989
34990   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34991   return jresult;
34992 }
34993
34994
34995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34996   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34997   bool arg2 ;
34998
34999   arg1 = (Dali::Actor *)jarg1;
35000   arg2 = jarg2 ? true : false;
35001   {
35002     try {
35003       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
35004     } catch (std::out_of_range& e) {
35005       {
35006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35007       };
35008     } catch (std::exception& e) {
35009       {
35010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35011       };
35012     } catch (Dali::DaliException e) {
35013       {
35014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35015       };
35016     } catch (...) {
35017       {
35018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35019       };
35020     }
35021   }
35022
35023 }
35024
35025
35026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
35027   unsigned int jresult ;
35028   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35029   bool result;
35030
35031   arg1 = (Dali::Actor *)jarg1;
35032   {
35033     try {
35034       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
35035     } catch (std::out_of_range& e) {
35036       {
35037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35038       };
35039     } catch (std::exception& e) {
35040       {
35041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35042       };
35043     } catch (Dali::DaliException e) {
35044       {
35045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35046       };
35047     } catch (...) {
35048       {
35049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35050       };
35051     }
35052   }
35053
35054   jresult = result;
35055   return jresult;
35056 }
35057
35058
35059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35060   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35061   Dali::Degree *arg2 = 0 ;
35062   Dali::Vector3 *arg3 = 0 ;
35063
35064   arg1 = (Dali::Actor *)jarg1;
35065   arg2 = (Dali::Degree *)jarg2;
35066   if (!arg2) {
35067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35068     return ;
35069   }
35070   arg3 = (Dali::Vector3 *)jarg3;
35071   if (!arg3) {
35072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35073     return ;
35074   }
35075   {
35076     try {
35077       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
35078     } catch (std::out_of_range& e) {
35079       {
35080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35081       };
35082     } catch (std::exception& e) {
35083       {
35084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35085       };
35086     } catch (Dali::DaliException e) {
35087       {
35088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35089       };
35090     } catch (...) {
35091       {
35092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35093       };
35094     }
35095   }
35096
35097 }
35098
35099
35100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35101   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35102   Dali::Radian *arg2 = 0 ;
35103   Dali::Vector3 *arg3 = 0 ;
35104
35105   arg1 = (Dali::Actor *)jarg1;
35106   arg2 = (Dali::Radian *)jarg2;
35107   if (!arg2) {
35108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35109     return ;
35110   }
35111   arg3 = (Dali::Vector3 *)jarg3;
35112   if (!arg3) {
35113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35114     return ;
35115   }
35116   {
35117     try {
35118       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
35119     } catch (std::out_of_range& e) {
35120       {
35121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35122       };
35123     } catch (std::exception& e) {
35124       {
35125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35126       };
35127     } catch (Dali::DaliException e) {
35128       {
35129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35130       };
35131     } catch (...) {
35132       {
35133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35134       };
35135     }
35136   }
35137
35138 }
35139
35140
35141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35142   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35143   Dali::Quaternion *arg2 = 0 ;
35144
35145   arg1 = (Dali::Actor *)jarg1;
35146   arg2 = (Dali::Quaternion *)jarg2;
35147   if (!arg2) {
35148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35149     return ;
35150   }
35151   {
35152     try {
35153       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
35154     } catch (std::out_of_range& e) {
35155       {
35156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35157       };
35158     } catch (std::exception& e) {
35159       {
35160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35161       };
35162     } catch (Dali::DaliException e) {
35163       {
35164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35165       };
35166     } catch (...) {
35167       {
35168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35169       };
35170     }
35171   }
35172
35173 }
35174
35175
35176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35177   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35178   Dali::Degree *arg2 = 0 ;
35179   Dali::Vector3 *arg3 = 0 ;
35180
35181   arg1 = (Dali::Actor *)jarg1;
35182   arg2 = (Dali::Degree *)jarg2;
35183   if (!arg2) {
35184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35185     return ;
35186   }
35187   arg3 = (Dali::Vector3 *)jarg3;
35188   if (!arg3) {
35189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35190     return ;
35191   }
35192   {
35193     try {
35194       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35195     } catch (std::out_of_range& e) {
35196       {
35197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35198       };
35199     } catch (std::exception& e) {
35200       {
35201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35202       };
35203     } catch (Dali::DaliException e) {
35204       {
35205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35206       };
35207     } catch (...) {
35208       {
35209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35210       };
35211     }
35212   }
35213
35214 }
35215
35216
35217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35218   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35219   Dali::Radian *arg2 = 0 ;
35220   Dali::Vector3 *arg3 = 0 ;
35221
35222   arg1 = (Dali::Actor *)jarg1;
35223   arg2 = (Dali::Radian *)jarg2;
35224   if (!arg2) {
35225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35226     return ;
35227   }
35228   arg3 = (Dali::Vector3 *)jarg3;
35229   if (!arg3) {
35230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35231     return ;
35232   }
35233   {
35234     try {
35235       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35236     } catch (std::out_of_range& e) {
35237       {
35238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35239       };
35240     } catch (std::exception& e) {
35241       {
35242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35243       };
35244     } catch (Dali::DaliException e) {
35245       {
35246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35247       };
35248     } catch (...) {
35249       {
35250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35251       };
35252     }
35253   }
35254
35255 }
35256
35257
35258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35259   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35260   Dali::Quaternion *arg2 = 0 ;
35261
35262   arg1 = (Dali::Actor *)jarg1;
35263   arg2 = (Dali::Quaternion *)jarg2;
35264   if (!arg2) {
35265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35266     return ;
35267   }
35268   {
35269     try {
35270       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35271     } catch (std::out_of_range& e) {
35272       {
35273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35274       };
35275     } catch (std::exception& e) {
35276       {
35277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35278       };
35279     } catch (Dali::DaliException e) {
35280       {
35281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35282       };
35283     } catch (...) {
35284       {
35285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35286       };
35287     }
35288   }
35289
35290 }
35291
35292
35293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35294   void * jresult ;
35295   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35296   Dali::Quaternion result;
35297
35298   arg1 = (Dali::Actor *)jarg1;
35299   {
35300     try {
35301       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
35302     } catch (std::out_of_range& e) {
35303       {
35304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35305       };
35306     } catch (std::exception& e) {
35307       {
35308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35309       };
35310     } catch (Dali::DaliException e) {
35311       {
35312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35313       };
35314     } catch (...) {
35315       {
35316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35317       };
35318     }
35319   }
35320
35321   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35322   return jresult;
35323 }
35324
35325
35326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35327   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35328   bool arg2 ;
35329
35330   arg1 = (Dali::Actor *)jarg1;
35331   arg2 = jarg2 ? true : false;
35332   {
35333     try {
35334       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
35335     } catch (std::out_of_range& e) {
35336       {
35337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35338       };
35339     } catch (std::exception& e) {
35340       {
35341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35342       };
35343     } catch (Dali::DaliException e) {
35344       {
35345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35346       };
35347     } catch (...) {
35348       {
35349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35350       };
35351     }
35352   }
35353
35354 }
35355
35356
35357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35358   unsigned int jresult ;
35359   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35360   bool result;
35361
35362   arg1 = (Dali::Actor *)jarg1;
35363   {
35364     try {
35365       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
35366     } catch (std::out_of_range& e) {
35367       {
35368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35369       };
35370     } catch (std::exception& e) {
35371       {
35372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35373       };
35374     } catch (Dali::DaliException e) {
35375       {
35376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35377       };
35378     } catch (...) {
35379       {
35380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35381       };
35382     }
35383   }
35384
35385   jresult = result;
35386   return jresult;
35387 }
35388
35389
35390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35391   void * jresult ;
35392   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35393   Dali::Quaternion result;
35394
35395   arg1 = (Dali::Actor *)jarg1;
35396   {
35397     try {
35398       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
35399     } catch (std::out_of_range& e) {
35400       {
35401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35402       };
35403     } catch (std::exception& e) {
35404       {
35405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35406       };
35407     } catch (Dali::DaliException e) {
35408       {
35409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35410       };
35411     } catch (...) {
35412       {
35413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35414       };
35415     }
35416   }
35417
35418   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35419   return jresult;
35420 }
35421
35422
35423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35424   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35425   float arg2 ;
35426
35427   arg1 = (Dali::Actor *)jarg1;
35428   arg2 = (float)jarg2;
35429   {
35430     try {
35431       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
35432     } catch (std::out_of_range& e) {
35433       {
35434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35435       };
35436     } catch (std::exception& e) {
35437       {
35438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35439       };
35440     } catch (Dali::DaliException e) {
35441       {
35442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35443       };
35444     } catch (...) {
35445       {
35446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35447       };
35448     }
35449   }
35450
35451 }
35452
35453
35454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35455   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35456   float arg2 ;
35457   float arg3 ;
35458   float arg4 ;
35459
35460   arg1 = (Dali::Actor *)jarg1;
35461   arg2 = (float)jarg2;
35462   arg3 = (float)jarg3;
35463   arg4 = (float)jarg4;
35464   {
35465     try {
35466       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
35467     } catch (std::out_of_range& e) {
35468       {
35469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35470       };
35471     } catch (std::exception& e) {
35472       {
35473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35474       };
35475     } catch (Dali::DaliException e) {
35476       {
35477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35478       };
35479     } catch (...) {
35480       {
35481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35482       };
35483     }
35484   }
35485
35486 }
35487
35488
35489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35490   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35491   Dali::Vector3 *arg2 = 0 ;
35492
35493   arg1 = (Dali::Actor *)jarg1;
35494   arg2 = (Dali::Vector3 *)jarg2;
35495   if (!arg2) {
35496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35497     return ;
35498   }
35499   {
35500     try {
35501       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
35502     } catch (std::out_of_range& e) {
35503       {
35504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35505       };
35506     } catch (std::exception& e) {
35507       {
35508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35509       };
35510     } catch (Dali::DaliException e) {
35511       {
35512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35513       };
35514     } catch (...) {
35515       {
35516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35517       };
35518     }
35519   }
35520
35521 }
35522
35523
35524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35525   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35526   Dali::Vector3 *arg2 = 0 ;
35527
35528   arg1 = (Dali::Actor *)jarg1;
35529   arg2 = (Dali::Vector3 *)jarg2;
35530   if (!arg2) {
35531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35532     return ;
35533   }
35534   {
35535     try {
35536       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35537     } catch (std::out_of_range& e) {
35538       {
35539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35540       };
35541     } catch (std::exception& e) {
35542       {
35543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35544       };
35545     } catch (Dali::DaliException e) {
35546       {
35547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35548       };
35549     } catch (...) {
35550       {
35551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35552       };
35553     }
35554   }
35555
35556 }
35557
35558
35559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35560   void * jresult ;
35561   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35562   Dali::Vector3 result;
35563
35564   arg1 = (Dali::Actor *)jarg1;
35565   {
35566     try {
35567       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
35568     } catch (std::out_of_range& e) {
35569       {
35570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35571       };
35572     } catch (std::exception& e) {
35573       {
35574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35575       };
35576     } catch (Dali::DaliException e) {
35577       {
35578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35579       };
35580     } catch (...) {
35581       {
35582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35583       };
35584     }
35585   }
35586
35587   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35588   return jresult;
35589 }
35590
35591
35592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35593   void * jresult ;
35594   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35595   Dali::Vector3 result;
35596
35597   arg1 = (Dali::Actor *)jarg1;
35598   {
35599     try {
35600       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
35601     } catch (std::out_of_range& e) {
35602       {
35603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35604       };
35605     } catch (std::exception& e) {
35606       {
35607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35608       };
35609     } catch (Dali::DaliException e) {
35610       {
35611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35612       };
35613     } catch (...) {
35614       {
35615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35616       };
35617     }
35618   }
35619
35620   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35621   return jresult;
35622 }
35623
35624
35625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35626   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35627   bool arg2 ;
35628
35629   arg1 = (Dali::Actor *)jarg1;
35630   arg2 = jarg2 ? true : false;
35631   {
35632     try {
35633       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
35634     } catch (std::out_of_range& e) {
35635       {
35636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35637       };
35638     } catch (std::exception& e) {
35639       {
35640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35641       };
35642     } catch (Dali::DaliException e) {
35643       {
35644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35645       };
35646     } catch (...) {
35647       {
35648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35649       };
35650     }
35651   }
35652
35653 }
35654
35655
35656 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35657   unsigned int jresult ;
35658   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35659   bool result;
35660
35661   arg1 = (Dali::Actor *)jarg1;
35662   {
35663     try {
35664       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
35665     } catch (std::out_of_range& e) {
35666       {
35667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35668       };
35669     } catch (std::exception& e) {
35670       {
35671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35672       };
35673     } catch (Dali::DaliException e) {
35674       {
35675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35676       };
35677     } catch (...) {
35678       {
35679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35680       };
35681     }
35682   }
35683
35684   jresult = result;
35685   return jresult;
35686 }
35687
35688
35689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35690   void * jresult ;
35691   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35692   Dali::Matrix result;
35693
35694   arg1 = (Dali::Actor *)jarg1;
35695   {
35696     try {
35697       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
35698     } catch (std::out_of_range& e) {
35699       {
35700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35701       };
35702     } catch (std::exception& e) {
35703       {
35704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35705       };
35706     } catch (Dali::DaliException e) {
35707       {
35708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35709       };
35710     } catch (...) {
35711       {
35712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35713       };
35714     }
35715   }
35716
35717   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35718   return jresult;
35719 }
35720
35721
35722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35723   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35724   bool arg2 ;
35725
35726   arg1 = (Dali::Actor *)jarg1;
35727   arg2 = jarg2 ? true : false;
35728   {
35729     try {
35730       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
35731     } catch (std::out_of_range& e) {
35732       {
35733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35734       };
35735     } catch (std::exception& e) {
35736       {
35737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35738       };
35739     } catch (Dali::DaliException e) {
35740       {
35741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35742       };
35743     } catch (...) {
35744       {
35745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35746       };
35747     }
35748   }
35749
35750 }
35751
35752
35753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35754   unsigned int jresult ;
35755   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35756   bool result;
35757
35758   arg1 = (Dali::Actor *)jarg1;
35759   {
35760     try {
35761       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
35762     } catch (std::out_of_range& e) {
35763       {
35764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35765       };
35766     } catch (std::exception& e) {
35767       {
35768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35769       };
35770     } catch (Dali::DaliException e) {
35771       {
35772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35773       };
35774     } catch (...) {
35775       {
35776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35777       };
35778     }
35779   }
35780
35781   jresult = result;
35782   return jresult;
35783 }
35784
35785
35786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35787   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35788   float arg2 ;
35789
35790   arg1 = (Dali::Actor *)jarg1;
35791   arg2 = (float)jarg2;
35792   {
35793     try {
35794       (arg1)->SetProperty( DevelActor::Property::OPACITY,arg2);
35795     } catch (std::out_of_range& e) {
35796       {
35797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35798       };
35799     } catch (std::exception& e) {
35800       {
35801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35802       };
35803     } catch (Dali::DaliException e) {
35804       {
35805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35806       };
35807     } catch (...) {
35808       {
35809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35810       };
35811     }
35812   }
35813
35814 }
35815
35816
35817 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35818   float jresult ;
35819   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35820   float result;
35821
35822   arg1 = (Dali::Actor *)jarg1;
35823   {
35824     try {
35825       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( DevelActor::Property::OPACITY );
35826     } catch (std::out_of_range& e) {
35827       {
35828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35829       };
35830     } catch (std::exception& e) {
35831       {
35832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35833       };
35834     } catch (Dali::DaliException e) {
35835       {
35836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35837       };
35838     } catch (...) {
35839       {
35840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35841       };
35842     }
35843   }
35844
35845   jresult = result;
35846   return jresult;
35847 }
35848
35849
35850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35851   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35852   Dali::Vector4 *arg2 = 0 ;
35853
35854   arg1 = (Dali::Actor *)jarg1;
35855   arg2 = (Dali::Vector4 *)jarg2;
35856   if (!arg2) {
35857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35858     return ;
35859   }
35860   {
35861     try {
35862       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
35863     } catch (std::out_of_range& e) {
35864       {
35865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35866       };
35867     } catch (std::exception& e) {
35868       {
35869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35870       };
35871     } catch (Dali::DaliException e) {
35872       {
35873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35874       };
35875     } catch (...) {
35876       {
35877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35878       };
35879     }
35880   }
35881
35882 }
35883
35884
35885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35886   void * jresult ;
35887   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35888   Dali::Vector4 result;
35889
35890   arg1 = (Dali::Actor *)jarg1;
35891   {
35892     try {
35893       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
35894     } catch (std::out_of_range& e) {
35895       {
35896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35897       };
35898     } catch (std::exception& e) {
35899       {
35900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35901       };
35902     } catch (Dali::DaliException e) {
35903       {
35904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35905       };
35906     } catch (...) {
35907       {
35908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35909       };
35910     }
35911   }
35912
35913   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35914   return jresult;
35915 }
35916
35917
35918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35919   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35920   Dali::ColorMode arg2 ;
35921
35922   arg1 = (Dali::Actor *)jarg1;
35923   arg2 = (Dali::ColorMode)jarg2;
35924   {
35925     try {
35926       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
35927     } catch (std::out_of_range& e) {
35928       {
35929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35930       };
35931     } catch (std::exception& e) {
35932       {
35933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35934       };
35935     } catch (Dali::DaliException e) {
35936       {
35937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35938       };
35939     } catch (...) {
35940       {
35941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35942       };
35943     }
35944   }
35945
35946 }
35947
35948
35949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35950   int jresult ;
35951   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35952   Dali::ColorMode result;
35953
35954   arg1 = (Dali::Actor *)jarg1;
35955   {
35956     try {
35957       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
35958     } catch (std::out_of_range& e) {
35959       {
35960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35961       };
35962     } catch (std::exception& e) {
35963       {
35964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35965       };
35966     } catch (Dali::DaliException e) {
35967       {
35968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35969       };
35970     } catch (...) {
35971       {
35972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35973       };
35974     }
35975   }
35976
35977   jresult = (int)result;
35978   return jresult;
35979 }
35980
35981
35982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35983   void * jresult ;
35984   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35985   Dali::Vector4 result;
35986
35987   arg1 = (Dali::Actor *)jarg1;
35988   {
35989     try {
35990       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
35991     } catch (std::out_of_range& e) {
35992       {
35993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35994       };
35995     } catch (std::exception& e) {
35996       {
35997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35998       };
35999     } catch (Dali::DaliException e) {
36000       {
36001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36002       };
36003     } catch (...) {
36004       {
36005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36006       };
36007     }
36008   }
36009
36010   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
36011   return jresult;
36012 }
36013
36014
36015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
36016   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36017   Dali::DrawMode::Type arg2 ;
36018
36019   arg1 = (Dali::Actor *)jarg1;
36020   arg2 = (Dali::DrawMode::Type)jarg2;
36021   {
36022     try {
36023       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
36024     } catch (std::out_of_range& e) {
36025       {
36026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36027       };
36028     } catch (std::exception& e) {
36029       {
36030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36031       };
36032     } catch (Dali::DaliException e) {
36033       {
36034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36035       };
36036     } catch (...) {
36037       {
36038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36039       };
36040     }
36041   }
36042
36043 }
36044
36045
36046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
36047   int jresult ;
36048   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36049   Dali::DrawMode::Type result;
36050
36051   arg1 = (Dali::Actor *)jarg1;
36052   {
36053     try {
36054       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
36055     } catch (std::out_of_range& e) {
36056       {
36057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36058       };
36059     } catch (std::exception& e) {
36060       {
36061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36062       };
36063     } catch (Dali::DaliException e) {
36064       {
36065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36066       };
36067     } catch (...) {
36068       {
36069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36070       };
36071     }
36072   }
36073
36074   jresult = (int)result;
36075   return jresult;
36076 }
36077
36078
36079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
36080   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36081   bool arg2 ;
36082
36083   arg1 = (Dali::Actor *)jarg1;
36084   arg2 = jarg2 ? true : false;
36085   {
36086     try {
36087       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
36088     } catch (std::out_of_range& e) {
36089       {
36090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36091       };
36092     } catch (std::exception& e) {
36093       {
36094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36095       };
36096     } catch (Dali::DaliException e) {
36097       {
36098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36099       };
36100     } catch (...) {
36101       {
36102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36103       };
36104     }
36105   }
36106
36107 }
36108
36109
36110 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
36111   unsigned int jresult ;
36112   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36113   bool result;
36114
36115   arg1 = (Dali::Actor *)jarg1;
36116   {
36117     try {
36118       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
36119     } catch (std::out_of_range& e) {
36120       {
36121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36122       };
36123     } catch (std::exception& e) {
36124       {
36125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36126       };
36127     } catch (Dali::DaliException e) {
36128       {
36129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36130       };
36131     } catch (...) {
36132       {
36133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36134       };
36135     }
36136   }
36137
36138   jresult = result;
36139   return jresult;
36140 }
36141
36142
36143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36144   unsigned int jresult ;
36145   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36146   float *arg2 = 0 ;
36147   float *arg3 = 0 ;
36148   float arg4 ;
36149   float arg5 ;
36150   bool result;
36151
36152   arg1 = (Dali::Actor *)jarg1;
36153   arg2 = (float *)jarg2;
36154   arg3 = (float *)jarg3;
36155   arg4 = (float)jarg4;
36156   arg5 = (float)jarg5;
36157   {
36158     try {
36159       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36160     } catch (std::out_of_range& e) {
36161       {
36162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36163       };
36164     } catch (std::exception& e) {
36165       {
36166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36167       };
36168     } catch (Dali::DaliException e) {
36169       {
36170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36171       };
36172     } catch (...) {
36173       {
36174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36175       };
36176     }
36177   }
36178
36179   jresult = result;
36180   return jresult;
36181 }
36182
36183
36184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36185   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36186   bool arg2 ;
36187
36188   arg1 = (Dali::Actor *)jarg1;
36189   arg2 = jarg2 ? true : false;
36190   {
36191     try {
36192       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
36193     } catch (std::out_of_range& e) {
36194       {
36195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36196       };
36197     } catch (std::exception& e) {
36198       {
36199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36200       };
36201     } catch (Dali::DaliException e) {
36202       {
36203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36204       };
36205     } catch (...) {
36206       {
36207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36208       };
36209     }
36210   }
36211
36212 }
36213
36214
36215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36216   unsigned int jresult ;
36217   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36218   bool result;
36219
36220   arg1 = (Dali::Actor *)jarg1;
36221   {
36222     try {
36223       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
36224     } catch (std::out_of_range& e) {
36225       {
36226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36227       };
36228     } catch (std::exception& e) {
36229       {
36230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36231       };
36232     } catch (Dali::DaliException e) {
36233       {
36234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36235       };
36236     } catch (...) {
36237       {
36238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36239       };
36240     }
36241   }
36242
36243   jresult = result;
36244   return jresult;
36245 }
36246
36247
36248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36249   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36250   bool arg2 ;
36251
36252   arg1 = (Dali::Actor *)jarg1;
36253   arg2 = jarg2 ? true : false;
36254   {
36255     try {
36256       (arg1)->SetKeyboardFocusable(arg2);
36257     } catch (std::out_of_range& e) {
36258       {
36259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36260       };
36261     } catch (std::exception& e) {
36262       {
36263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36264       };
36265     } catch (Dali::DaliException e) {
36266       {
36267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36268       };
36269     } catch (...) {
36270       {
36271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36272       };
36273     }
36274   }
36275
36276 }
36277
36278
36279 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36280   unsigned int jresult ;
36281   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36282   bool result;
36283
36284   arg1 = (Dali::Actor *)jarg1;
36285   {
36286     try {
36287       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36288     } catch (std::out_of_range& e) {
36289       {
36290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36291       };
36292     } catch (std::exception& e) {
36293       {
36294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36295       };
36296     } catch (Dali::DaliException e) {
36297       {
36298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36299       };
36300     } catch (...) {
36301       {
36302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36303       };
36304     }
36305   }
36306
36307   jresult = result;
36308   return jresult;
36309 }
36310
36311
36312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36313   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36314   Dali::ResizePolicy::Type arg2 ;
36315   Dali::Dimension::Type arg3 ;
36316
36317   arg1 = (Dali::Actor *)jarg1;
36318   arg2 = (Dali::ResizePolicy::Type)jarg2;
36319   arg3 = (Dali::Dimension::Type)jarg3;
36320   {
36321     try {
36322       (arg1)->SetResizePolicy(arg2,arg3);
36323     } catch (std::out_of_range& e) {
36324       {
36325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36326       };
36327     } catch (std::exception& e) {
36328       {
36329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36330       };
36331     } catch (Dali::DaliException e) {
36332       {
36333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36334       };
36335     } catch (...) {
36336       {
36337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36338       };
36339     }
36340   }
36341
36342 }
36343
36344
36345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36346   int jresult ;
36347   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36348   Dali::Dimension::Type arg2 ;
36349   Dali::ResizePolicy::Type result;
36350
36351   arg1 = (Dali::Actor *)jarg1;
36352   arg2 = (Dali::Dimension::Type)jarg2;
36353   {
36354     try {
36355       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36356     } catch (std::out_of_range& e) {
36357       {
36358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36359       };
36360     } catch (std::exception& e) {
36361       {
36362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36363       };
36364     } catch (Dali::DaliException e) {
36365       {
36366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36367       };
36368     } catch (...) {
36369       {
36370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36371       };
36372     }
36373   }
36374
36375   jresult = (int)result;
36376   return jresult;
36377 }
36378
36379
36380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36381   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36382   Dali::SizeScalePolicy::Type arg2 ;
36383
36384   arg1 = (Dali::Actor *)jarg1;
36385   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36386   {
36387     try {
36388       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
36389     } catch (std::out_of_range& e) {
36390       {
36391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36392       };
36393     } catch (std::exception& e) {
36394       {
36395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36396       };
36397     } catch (Dali::DaliException e) {
36398       {
36399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36400       };
36401     } catch (...) {
36402       {
36403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36404       };
36405     }
36406   }
36407
36408 }
36409
36410
36411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36412   int jresult ;
36413   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36414   Dali::SizeScalePolicy::Type result;
36415
36416   arg1 = (Dali::Actor *)jarg1;
36417   {
36418     try {
36419       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
36420     } catch (std::out_of_range& e) {
36421       {
36422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36423       };
36424     } catch (std::exception& e) {
36425       {
36426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36427       };
36428     } catch (Dali::DaliException e) {
36429       {
36430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36431       };
36432     } catch (...) {
36433       {
36434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36435       };
36436     }
36437   }
36438
36439   jresult = (int)result;
36440   return jresult;
36441 }
36442
36443
36444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36445   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36446   Dali::Vector3 *arg2 = 0 ;
36447
36448   arg1 = (Dali::Actor *)jarg1;
36449   arg2 = (Dali::Vector3 *)jarg2;
36450   if (!arg2) {
36451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36452     return ;
36453   }
36454   {
36455     try {
36456       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
36457     } catch (std::out_of_range& e) {
36458       {
36459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36460       };
36461     } catch (std::exception& e) {
36462       {
36463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36464       };
36465     } catch (Dali::DaliException e) {
36466       {
36467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36468       };
36469     } catch (...) {
36470       {
36471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36472       };
36473     }
36474   }
36475
36476 }
36477
36478
36479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36480   void * jresult ;
36481   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36482   Dali::Vector3 result;
36483
36484   arg1 = (Dali::Actor *)jarg1;
36485   {
36486     try {
36487       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
36488     } catch (std::out_of_range& e) {
36489       {
36490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36491       };
36492     } catch (std::exception& e) {
36493       {
36494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36495       };
36496     } catch (Dali::DaliException e) {
36497       {
36498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36499       };
36500     } catch (...) {
36501       {
36502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36503       };
36504     }
36505   }
36506
36507   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36508   return jresult;
36509 }
36510
36511
36512 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36513   float jresult ;
36514   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36515   float arg2 ;
36516   float result;
36517
36518   arg1 = (Dali::Actor *)jarg1;
36519   arg2 = (float)jarg2;
36520   {
36521     try {
36522       result = (float)(arg1)->GetHeightForWidth(arg2);
36523     } catch (std::out_of_range& e) {
36524       {
36525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36526       };
36527     } catch (std::exception& e) {
36528       {
36529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36530       };
36531     } catch (Dali::DaliException e) {
36532       {
36533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36534       };
36535     } catch (...) {
36536       {
36537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36538       };
36539     }
36540   }
36541
36542   jresult = result;
36543   return jresult;
36544 }
36545
36546
36547 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36548   float jresult ;
36549   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36550   float arg2 ;
36551   float result;
36552
36553   arg1 = (Dali::Actor *)jarg1;
36554   arg2 = (float)jarg2;
36555   {
36556     try {
36557       result = (float)(arg1)->GetWidthForHeight(arg2);
36558     } catch (std::out_of_range& e) {
36559       {
36560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36561       };
36562     } catch (std::exception& e) {
36563       {
36564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36565       };
36566     } catch (Dali::DaliException e) {
36567       {
36568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36569       };
36570     } catch (...) {
36571       {
36572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36573       };
36574     }
36575   }
36576
36577   jresult = result;
36578   return jresult;
36579 }
36580
36581
36582 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36583   float jresult ;
36584   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36585   Dali::Dimension::Type arg2 ;
36586   float result;
36587
36588   arg1 = (Dali::Actor *)jarg1;
36589   arg2 = (Dali::Dimension::Type)jarg2;
36590   {
36591     try {
36592       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36593     } catch (std::out_of_range& e) {
36594       {
36595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36596       };
36597     } catch (std::exception& e) {
36598       {
36599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36600       };
36601     } catch (Dali::DaliException e) {
36602       {
36603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36604       };
36605     } catch (...) {
36606       {
36607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36608       };
36609     }
36610   }
36611
36612   jresult = result;
36613   return jresult;
36614 }
36615
36616
36617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36618   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36619   Dali::Padding *arg2 = 0 ;
36620
36621   arg1 = (Dali::Actor *)jarg1;
36622   arg2 = (Dali::Padding *)jarg2;
36623   if (!arg2) {
36624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36625     return ;
36626   }
36627   {
36628     try {
36629       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
36630     } catch (std::out_of_range& e) {
36631       {
36632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36633       };
36634     } catch (std::exception& e) {
36635       {
36636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36637       };
36638     } catch (Dali::DaliException e) {
36639       {
36640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36641       };
36642     } catch (...) {
36643       {
36644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36645       };
36646     }
36647   }
36648
36649 }
36650
36651
36652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36653   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36654   Dali::Padding *arg2 = 0 ;
36655
36656   arg1 = (Dali::Actor *)jarg1;
36657   arg2 = (Dali::Padding *)jarg2;
36658   if (!arg2) {
36659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36660     return ;
36661   }
36662   {
36663     try {
36664       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
36665     } catch (std::out_of_range& e) {
36666       {
36667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36668       };
36669     } catch (std::exception& e) {
36670       {
36671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36672       };
36673     } catch (Dali::DaliException e) {
36674       {
36675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36676       };
36677     } catch (...) {
36678       {
36679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36680       };
36681     }
36682   }
36683
36684 }
36685
36686
36687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36688   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36689   Dali::Vector2 *arg2 = 0 ;
36690
36691   arg1 = (Dali::Actor *)jarg1;
36692   arg2 = (Dali::Vector2 *)jarg2;
36693   if (!arg2) {
36694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36695     return ;
36696   }
36697   {
36698     try {
36699       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36700     } catch (std::out_of_range& e) {
36701       {
36702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36703       };
36704     } catch (std::exception& e) {
36705       {
36706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36707       };
36708     } catch (Dali::DaliException e) {
36709       {
36710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36711       };
36712     } catch (...) {
36713       {
36714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36715       };
36716     }
36717   }
36718
36719 }
36720
36721
36722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36723   void * jresult ;
36724   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36725   Dali::Vector2 result;
36726
36727   arg1 = (Dali::Actor *)jarg1;
36728   {
36729     try {
36730       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
36731     } catch (std::out_of_range& e) {
36732       {
36733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36734       };
36735     } catch (std::exception& e) {
36736       {
36737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36738       };
36739     } catch (Dali::DaliException e) {
36740       {
36741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36742       };
36743     } catch (...) {
36744       {
36745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36746       };
36747     }
36748   }
36749
36750   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36751   return jresult;
36752 }
36753
36754
36755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36756   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36757   Dali::Vector2 *arg2 = 0 ;
36758
36759   arg1 = (Dali::Actor *)jarg1;
36760   arg2 = (Dali::Vector2 *)jarg2;
36761   if (!arg2) {
36762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36763     return ;
36764   }
36765   {
36766     try {
36767       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36768     } catch (std::out_of_range& e) {
36769       {
36770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36771       };
36772     } catch (std::exception& e) {
36773       {
36774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36775       };
36776     } catch (Dali::DaliException e) {
36777       {
36778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36779       };
36780     } catch (...) {
36781       {
36782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36783       };
36784     }
36785   }
36786
36787 }
36788
36789
36790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36791   void * jresult ;
36792   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36793   Dali::Vector2 result;
36794
36795   arg1 = (Dali::Actor *)jarg1;
36796   {
36797     try {
36798       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
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 = new Dali::Vector2((const Dali::Vector2 &)result);
36819   return jresult;
36820 }
36821
36822
36823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36824   int jresult ;
36825   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36826   int result;
36827
36828   arg1 = (Dali::Actor *)jarg1;
36829   {
36830     try {
36831       result = (int)(arg1)->GetHierarchyDepth();
36832       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36833     } catch (std::out_of_range& e) {
36834       {
36835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36836       };
36837     } catch (std::exception& e) {
36838       {
36839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36840       };
36841     } catch (Dali::DaliException e) {
36842       {
36843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36844       };
36845     } catch (...) {
36846       {
36847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36848       };
36849     }
36850   }
36851
36852   jresult = result;
36853   return jresult;
36854 }
36855
36856
36857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36858   unsigned int jresult ;
36859   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36860   Dali::Renderer *arg2 = 0 ;
36861   unsigned int result;
36862
36863   arg1 = (Dali::Actor *)jarg1;
36864   arg2 = (Dali::Renderer *)jarg2;
36865   if (!arg2) {
36866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36867     return 0;
36868   }
36869   {
36870     try {
36871       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36872     } catch (std::out_of_range& e) {
36873       {
36874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36875       };
36876     } catch (std::exception& e) {
36877       {
36878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36879       };
36880     } catch (Dali::DaliException e) {
36881       {
36882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36883       };
36884     } catch (...) {
36885       {
36886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36887       };
36888     }
36889   }
36890
36891   jresult = result;
36892   return jresult;
36893 }
36894
36895
36896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36897   unsigned int jresult ;
36898   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36899   unsigned int result;
36900
36901   arg1 = (Dali::Actor *)jarg1;
36902   {
36903     try {
36904       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36905     } catch (std::out_of_range& e) {
36906       {
36907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36908       };
36909     } catch (std::exception& e) {
36910       {
36911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36912       };
36913     } catch (Dali::DaliException e) {
36914       {
36915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36916       };
36917     } catch (...) {
36918       {
36919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36920       };
36921     }
36922   }
36923
36924   jresult = result;
36925   return jresult;
36926 }
36927
36928
36929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36930   void * jresult ;
36931   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36932   unsigned int arg2 ;
36933   Dali::Renderer result;
36934
36935   arg1 = (Dali::Actor *)jarg1;
36936   arg2 = (unsigned int)jarg2;
36937   {
36938     try {
36939       result = (arg1)->GetRendererAt(arg2);
36940     } catch (std::out_of_range& e) {
36941       {
36942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36943       };
36944     } catch (std::exception& e) {
36945       {
36946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36947       };
36948     } catch (Dali::DaliException e) {
36949       {
36950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36951       };
36952     } catch (...) {
36953       {
36954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36955       };
36956     }
36957   }
36958
36959   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36960   return jresult;
36961 }
36962
36963
36964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36965   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36966   Dali::Renderer *arg2 = 0 ;
36967
36968   arg1 = (Dali::Actor *)jarg1;
36969   arg2 = (Dali::Renderer *)jarg2;
36970   if (!arg2) {
36971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36972     return ;
36973   }
36974   {
36975     try {
36976       (arg1)->RemoveRenderer(*arg2);
36977     } catch (std::out_of_range& e) {
36978       {
36979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36980       };
36981     } catch (std::exception& e) {
36982       {
36983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36984       };
36985     } catch (Dali::DaliException e) {
36986       {
36987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36988       };
36989     } catch (...) {
36990       {
36991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36992       };
36993     }
36994   }
36995
36996 }
36997
36998
36999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
37000   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37001   unsigned int arg2 ;
37002
37003   arg1 = (Dali::Actor *)jarg1;
37004   arg2 = (unsigned int)jarg2;
37005   {
37006     try {
37007       (arg1)->RemoveRenderer(arg2);
37008     } catch (std::out_of_range& e) {
37009       {
37010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37011       };
37012     } catch (std::exception& e) {
37013       {
37014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37015       };
37016     } catch (Dali::DaliException e) {
37017       {
37018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37019       };
37020     } catch (...) {
37021       {
37022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37023       };
37024     }
37025   }
37026
37027 }
37028
37029
37030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
37031   void * jresult ;
37032   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37033   Dali::Actor::TouchSignalType *result = 0 ;
37034
37035   arg1 = (Dali::Actor *)jarg1;
37036   {
37037     try {
37038       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
37039     } catch (std::out_of_range& e) {
37040       {
37041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37042       };
37043     } catch (std::exception& e) {
37044       {
37045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37046       };
37047     } catch (Dali::DaliException e) {
37048       {
37049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37050       };
37051     } catch (...) {
37052       {
37053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37054       };
37055     }
37056   }
37057
37058   jresult = (void *)result;
37059   return jresult;
37060 }
37061
37062
37063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
37064   void * jresult ;
37065   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37066   Dali::Actor::TouchDataSignalType *result = 0 ;
37067
37068   arg1 = (Dali::Actor *)jarg1;
37069   {
37070     try {
37071       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
37072     } catch (std::out_of_range& e) {
37073       {
37074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37075       };
37076     } catch (std::exception& e) {
37077       {
37078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37079       };
37080     } catch (Dali::DaliException e) {
37081       {
37082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37083       };
37084     } catch (...) {
37085       {
37086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37087       };
37088     }
37089   }
37090
37091   jresult = (void *)result;
37092   return jresult;
37093 }
37094
37095
37096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
37097   void * jresult ;
37098   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37099   Dali::Actor::HoverSignalType *result = 0 ;
37100
37101   arg1 = (Dali::Actor *)jarg1;
37102   {
37103     try {
37104       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
37105     } catch (std::out_of_range& e) {
37106       {
37107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37108       };
37109     } catch (std::exception& e) {
37110       {
37111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37112       };
37113     } catch (Dali::DaliException e) {
37114       {
37115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37116       };
37117     } catch (...) {
37118       {
37119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37120       };
37121     }
37122   }
37123
37124   jresult = (void *)result;
37125   return jresult;
37126 }
37127
37128
37129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
37130   void * jresult ;
37131   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37132   Dali::Actor::WheelEventSignalType *result = 0 ;
37133
37134   arg1 = (Dali::Actor *)jarg1;
37135   {
37136     try {
37137       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37138     } catch (std::out_of_range& e) {
37139       {
37140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37141       };
37142     } catch (std::exception& e) {
37143       {
37144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37145       };
37146     } catch (Dali::DaliException e) {
37147       {
37148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37149       };
37150     } catch (...) {
37151       {
37152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37153       };
37154     }
37155   }
37156
37157   jresult = (void *)result;
37158   return jresult;
37159 }
37160
37161
37162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
37163   void * jresult ;
37164   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37165   Dali::Actor::OnStageSignalType *result = 0 ;
37166
37167   arg1 = (Dali::Actor *)jarg1;
37168   {
37169     try {
37170       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37171     } catch (std::out_of_range& e) {
37172       {
37173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37174       };
37175     } catch (std::exception& e) {
37176       {
37177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37178       };
37179     } catch (Dali::DaliException e) {
37180       {
37181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37182       };
37183     } catch (...) {
37184       {
37185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37186       };
37187     }
37188   }
37189
37190   jresult = (void *)result;
37191   return jresult;
37192 }
37193
37194
37195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37196   void * jresult ;
37197   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37198   Dali::Actor::OffStageSignalType *result = 0 ;
37199
37200   arg1 = (Dali::Actor *)jarg1;
37201   {
37202     try {
37203       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37204     } catch (std::out_of_range& e) {
37205       {
37206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37207       };
37208     } catch (std::exception& e) {
37209       {
37210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37211       };
37212     } catch (Dali::DaliException e) {
37213       {
37214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37215       };
37216     } catch (...) {
37217       {
37218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37219       };
37220     }
37221   }
37222
37223   jresult = (void *)result;
37224   return jresult;
37225 }
37226
37227
37228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37229   void * jresult ;
37230   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37231   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37232
37233   arg1 = (Dali::Actor *)jarg1;
37234   {
37235     try {
37236       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37237     } catch (std::out_of_range& e) {
37238       {
37239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37240       };
37241     } catch (std::exception& e) {
37242       {
37243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37244       };
37245     } catch (Dali::DaliException e) {
37246       {
37247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37248       };
37249     } catch (...) {
37250       {
37251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37252       };
37253     }
37254   }
37255
37256   jresult = (void *)result;
37257   return jresult;
37258 }
37259
37260
37261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37262   Dali::Actor *arg1 = 0 ;
37263
37264   arg1 = (Dali::Actor *)jarg1;
37265   if (!arg1) {
37266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37267     return ;
37268   }
37269   {
37270     try {
37271       Dali::UnparentAndReset(*arg1);
37272     } catch (std::out_of_range& e) {
37273       {
37274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37275       };
37276     } catch (std::exception& e) {
37277       {
37278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37279       };
37280     } catch (Dali::DaliException e) {
37281       {
37282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37283       };
37284     } catch (...) {
37285       {
37286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37287       };
37288     }
37289   }
37290
37291 }
37292
37293
37294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37295   int jresult ;
37296   int result;
37297
37298   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37299   jresult = (int)result;
37300   return jresult;
37301 }
37302
37303
37304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37305   int jresult ;
37306   int result;
37307
37308   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37309   jresult = (int)result;
37310   return jresult;
37311 }
37312
37313
37314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37315   int jresult ;
37316   int result;
37317
37318   result = (int)Dali::Layer::Property::BEHAVIOR;
37319   jresult = (int)result;
37320   return jresult;
37321 }
37322
37323
37324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37325   void * jresult ;
37326   Dali::Layer::Property *result = 0 ;
37327
37328   {
37329     try {
37330       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37331     } catch (std::out_of_range& e) {
37332       {
37333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37334       };
37335     } catch (std::exception& e) {
37336       {
37337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37338       };
37339     } catch (Dali::DaliException e) {
37340       {
37341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37342       };
37343     } catch (...) {
37344       {
37345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37346       };
37347     }
37348   }
37349
37350   jresult = (void *)result;
37351   return jresult;
37352 }
37353
37354
37355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37356   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37357
37358   arg1 = (Dali::Layer::Property *)jarg1;
37359   {
37360     try {
37361       delete arg1;
37362     } catch (std::out_of_range& e) {
37363       {
37364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37365       };
37366     } catch (std::exception& e) {
37367       {
37368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37369       };
37370     } catch (Dali::DaliException e) {
37371       {
37372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37373       };
37374     } catch (...) {
37375       {
37376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37377       };
37378     }
37379   }
37380
37381 }
37382
37383
37384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37385   void * jresult ;
37386   Dali::Layer *result = 0 ;
37387
37388   {
37389     try {
37390       result = (Dali::Layer *)new Dali::Layer();
37391     } catch (std::out_of_range& e) {
37392       {
37393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37394       };
37395     } catch (std::exception& e) {
37396       {
37397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37398       };
37399     } catch (Dali::DaliException e) {
37400       {
37401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37402       };
37403     } catch (...) {
37404       {
37405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37406       };
37407     }
37408   }
37409
37410   jresult = (void *)result;
37411   return jresult;
37412 }
37413
37414
37415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37416   void * jresult ;
37417   Dali::Layer result;
37418
37419   {
37420     try {
37421       result = Dali::Layer::New();
37422     } catch (std::out_of_range& e) {
37423       {
37424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37425       };
37426     } catch (std::exception& e) {
37427       {
37428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37429       };
37430     } catch (Dali::DaliException e) {
37431       {
37432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37433       };
37434     } catch (...) {
37435       {
37436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37437       };
37438     }
37439   }
37440
37441   jresult = new Dali::Layer((const Dali::Layer &)result);
37442   return jresult;
37443 }
37444
37445
37446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37447   void * jresult ;
37448   Dali::BaseHandle arg1 ;
37449   Dali::BaseHandle *argp1 ;
37450   Dali::Layer result;
37451
37452   argp1 = (Dali::BaseHandle *)jarg1;
37453   if (!argp1) {
37454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37455     return 0;
37456   }
37457   arg1 = *argp1;
37458   {
37459     try {
37460       result = Dali::Layer::DownCast(arg1);
37461     } catch (std::out_of_range& e) {
37462       {
37463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37464       };
37465     } catch (std::exception& e) {
37466       {
37467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37468       };
37469     } catch (Dali::DaliException e) {
37470       {
37471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37472       };
37473     } catch (...) {
37474       {
37475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37476       };
37477     }
37478   }
37479
37480   jresult = new Dali::Layer((const Dali::Layer &)result);
37481   return jresult;
37482 }
37483
37484
37485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37486   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37487
37488   arg1 = (Dali::Layer *)jarg1;
37489   {
37490     try {
37491       delete arg1;
37492     } catch (std::out_of_range& e) {
37493       {
37494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37495       };
37496     } catch (std::exception& e) {
37497       {
37498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37499       };
37500     } catch (Dali::DaliException e) {
37501       {
37502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37503       };
37504     } catch (...) {
37505       {
37506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37507       };
37508     }
37509   }
37510
37511 }
37512
37513
37514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37515   void * jresult ;
37516   Dali::Layer *arg1 = 0 ;
37517   Dali::Layer *result = 0 ;
37518
37519   arg1 = (Dali::Layer *)jarg1;
37520   if (!arg1) {
37521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37522     return 0;
37523   }
37524   {
37525     try {
37526       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37527     } catch (std::out_of_range& e) {
37528       {
37529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37530       };
37531     } catch (std::exception& e) {
37532       {
37533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37534       };
37535     } catch (Dali::DaliException e) {
37536       {
37537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37538       };
37539     } catch (...) {
37540       {
37541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37542       };
37543     }
37544   }
37545
37546   jresult = (void *)result;
37547   return jresult;
37548 }
37549
37550
37551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37552   void * jresult ;
37553   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37554   Dali::Layer *arg2 = 0 ;
37555   Dali::Layer *result = 0 ;
37556
37557   arg1 = (Dali::Layer *)jarg1;
37558   arg2 = (Dali::Layer *)jarg2;
37559   if (!arg2) {
37560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37561     return 0;
37562   }
37563   {
37564     try {
37565       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37566     } catch (std::out_of_range& e) {
37567       {
37568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37569       };
37570     } catch (std::exception& e) {
37571       {
37572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37573       };
37574     } catch (Dali::DaliException e) {
37575       {
37576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37577       };
37578     } catch (...) {
37579       {
37580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37581       };
37582     }
37583   }
37584
37585   jresult = (void *)result;
37586   return jresult;
37587 }
37588
37589
37590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37591   unsigned int jresult ;
37592   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37593   unsigned int result;
37594
37595   arg1 = (Dali::Layer *)jarg1;
37596   {
37597     try {
37598       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37599     } catch (std::out_of_range& e) {
37600       {
37601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37602       };
37603     } catch (std::exception& e) {
37604       {
37605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37606       };
37607     } catch (Dali::DaliException e) {
37608       {
37609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37610       };
37611     } catch (...) {
37612       {
37613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37614       };
37615     }
37616   }
37617
37618   jresult = result;
37619   return jresult;
37620 }
37621
37622
37623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37624   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37625
37626   arg1 = (Dali::Layer *)jarg1;
37627   {
37628     try {
37629       (arg1)->Raise();
37630     } catch (std::out_of_range& e) {
37631       {
37632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37633       };
37634     } catch (std::exception& e) {
37635       {
37636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37637       };
37638     } catch (Dali::DaliException e) {
37639       {
37640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37641       };
37642     } catch (...) {
37643       {
37644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37645       };
37646     }
37647   }
37648
37649 }
37650
37651
37652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37653   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37654
37655   arg1 = (Dali::Layer *)jarg1;
37656   {
37657     try {
37658       (arg1)->Lower();
37659     } catch (std::out_of_range& e) {
37660       {
37661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37662       };
37663     } catch (std::exception& e) {
37664       {
37665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37666       };
37667     } catch (Dali::DaliException e) {
37668       {
37669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37670       };
37671     } catch (...) {
37672       {
37673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37674       };
37675     }
37676   }
37677
37678 }
37679
37680
37681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37682   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37683   Dali::Layer arg2 ;
37684   Dali::Layer *argp2 ;
37685
37686   arg1 = (Dali::Layer *)jarg1;
37687   argp2 = (Dali::Layer *)jarg2;
37688   if (!argp2) {
37689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37690     return ;
37691   }
37692   arg2 = *argp2;
37693   {
37694     try {
37695       (arg1)->RaiseAbove(arg2);
37696     } catch (std::out_of_range& e) {
37697       {
37698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37699       };
37700     } catch (std::exception& e) {
37701       {
37702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37703       };
37704     } catch (Dali::DaliException e) {
37705       {
37706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37707       };
37708     } catch (...) {
37709       {
37710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37711       };
37712     }
37713   }
37714
37715 }
37716
37717
37718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37719   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37720   Dali::Layer arg2 ;
37721   Dali::Layer *argp2 ;
37722
37723   arg1 = (Dali::Layer *)jarg1;
37724   argp2 = (Dali::Layer *)jarg2;
37725   if (!argp2) {
37726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37727     return ;
37728   }
37729   arg2 = *argp2;
37730   {
37731     try {
37732       (arg1)->LowerBelow(arg2);
37733     } catch (std::out_of_range& e) {
37734       {
37735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37736       };
37737     } catch (std::exception& e) {
37738       {
37739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37740       };
37741     } catch (Dali::DaliException e) {
37742       {
37743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37744       };
37745     } catch (...) {
37746       {
37747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37748       };
37749     }
37750   }
37751
37752 }
37753
37754
37755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37756   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37757
37758   arg1 = (Dali::Layer *)jarg1;
37759   {
37760     try {
37761       (arg1)->RaiseToTop();
37762     } catch (std::out_of_range& e) {
37763       {
37764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37765       };
37766     } catch (std::exception& e) {
37767       {
37768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37769       };
37770     } catch (Dali::DaliException e) {
37771       {
37772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37773       };
37774     } catch (...) {
37775       {
37776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37777       };
37778     }
37779   }
37780
37781 }
37782
37783
37784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37785   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37786
37787   arg1 = (Dali::Layer *)jarg1;
37788   {
37789     try {
37790       (arg1)->LowerToBottom();
37791     } catch (std::out_of_range& e) {
37792       {
37793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37794       };
37795     } catch (std::exception& e) {
37796       {
37797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37798       };
37799     } catch (Dali::DaliException e) {
37800       {
37801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37802       };
37803     } catch (...) {
37804       {
37805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37806       };
37807     }
37808   }
37809
37810 }
37811
37812
37813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37814   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37815   Dali::Layer arg2 ;
37816   Dali::Layer *argp2 ;
37817
37818   arg1 = (Dali::Layer *)jarg1;
37819   argp2 = (Dali::Layer *)jarg2;
37820   if (!argp2) {
37821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37822     return ;
37823   }
37824   arg2 = *argp2;
37825   {
37826     try {
37827       (arg1)->MoveAbove(arg2);
37828     } catch (std::out_of_range& e) {
37829       {
37830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37831       };
37832     } catch (std::exception& e) {
37833       {
37834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37835       };
37836     } catch (Dali::DaliException e) {
37837       {
37838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37839       };
37840     } catch (...) {
37841       {
37842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37843       };
37844     }
37845   }
37846
37847 }
37848
37849
37850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37851   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37852   Dali::Layer arg2 ;
37853   Dali::Layer *argp2 ;
37854
37855   arg1 = (Dali::Layer *)jarg1;
37856   argp2 = (Dali::Layer *)jarg2;
37857   if (!argp2) {
37858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37859     return ;
37860   }
37861   arg2 = *argp2;
37862   {
37863     try {
37864       (arg1)->MoveBelow(arg2);
37865     } catch (std::out_of_range& e) {
37866       {
37867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37868       };
37869     } catch (std::exception& e) {
37870       {
37871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37872       };
37873     } catch (Dali::DaliException e) {
37874       {
37875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37876       };
37877     } catch (...) {
37878       {
37879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37880       };
37881     }
37882   }
37883
37884 }
37885
37886
37887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37888   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37889   Dali::Layer::Behavior arg2 ;
37890
37891   arg1 = (Dali::Layer *)jarg1;
37892   arg2 = (Dali::Layer::Behavior)jarg2;
37893   {
37894     try {
37895       (arg1)->SetBehavior(arg2);
37896     } catch (std::out_of_range& e) {
37897       {
37898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37899       };
37900     } catch (std::exception& e) {
37901       {
37902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37903       };
37904     } catch (Dali::DaliException e) {
37905       {
37906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37907       };
37908     } catch (...) {
37909       {
37910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37911       };
37912     }
37913   }
37914
37915 }
37916
37917
37918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37919   int jresult ;
37920   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37921   Dali::Layer::Behavior result;
37922
37923   arg1 = (Dali::Layer *)jarg1;
37924   {
37925     try {
37926       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37927     } catch (std::out_of_range& e) {
37928       {
37929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37930       };
37931     } catch (std::exception& e) {
37932       {
37933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37934       };
37935     } catch (Dali::DaliException e) {
37936       {
37937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37938       };
37939     } catch (...) {
37940       {
37941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37942       };
37943     }
37944   }
37945
37946   jresult = (int)result;
37947   return jresult;
37948 }
37949
37950
37951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37952   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37953   bool arg2 ;
37954
37955   arg1 = (Dali::Layer *)jarg1;
37956   arg2 = jarg2 ? true : false;
37957   {
37958     try {
37959       (arg1)->SetClipping(arg2);
37960     } catch (std::out_of_range& e) {
37961       {
37962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37963       };
37964     } catch (std::exception& e) {
37965       {
37966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37967       };
37968     } catch (Dali::DaliException e) {
37969       {
37970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37971       };
37972     } catch (...) {
37973       {
37974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37975       };
37976     }
37977   }
37978
37979 }
37980
37981
37982 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37983   unsigned int jresult ;
37984   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37985   bool result;
37986
37987   arg1 = (Dali::Layer *)jarg1;
37988   {
37989     try {
37990       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37991     } catch (std::out_of_range& e) {
37992       {
37993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37994       };
37995     } catch (std::exception& e) {
37996       {
37997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37998       };
37999     } catch (Dali::DaliException e) {
38000       {
38001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38002       };
38003     } catch (...) {
38004       {
38005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38006       };
38007     }
38008   }
38009
38010   jresult = result;
38011   return jresult;
38012 }
38013
38014
38015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
38016   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38017   int arg2 ;
38018   int arg3 ;
38019   int arg4 ;
38020   int arg5 ;
38021
38022   arg1 = (Dali::Layer *)jarg1;
38023   arg2 = (int)jarg2;
38024   arg3 = (int)jarg3;
38025   arg4 = (int)jarg4;
38026   arg5 = (int)jarg5;
38027   {
38028     try {
38029       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
38030     } catch (std::out_of_range& e) {
38031       {
38032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38033       };
38034     } catch (std::exception& e) {
38035       {
38036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38037       };
38038     } catch (Dali::DaliException e) {
38039       {
38040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38041       };
38042     } catch (...) {
38043       {
38044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38045       };
38046     }
38047   }
38048
38049 }
38050
38051
38052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
38053   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38054   Dali::ClippingBox arg2 ;
38055   Dali::ClippingBox *argp2 ;
38056
38057   arg1 = (Dali::Layer *)jarg1;
38058   argp2 = (Dali::ClippingBox *)jarg2;
38059   if (!argp2) {
38060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
38061     return ;
38062   }
38063   arg2 = *argp2;
38064   {
38065     try {
38066       (arg1)->SetClippingBox(arg2);
38067     } catch (std::out_of_range& e) {
38068       {
38069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38070       };
38071     } catch (std::exception& e) {
38072       {
38073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38074       };
38075     } catch (Dali::DaliException e) {
38076       {
38077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38078       };
38079     } catch (...) {
38080       {
38081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38082       };
38083     }
38084   }
38085
38086 }
38087
38088
38089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
38090   void * jresult ;
38091   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38092   Dali::ClippingBox result;
38093
38094   arg1 = (Dali::Layer *)jarg1;
38095   {
38096     try {
38097       result = ((Dali::Layer const *)arg1)->GetClippingBox();
38098     } catch (std::out_of_range& e) {
38099       {
38100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38101       };
38102     } catch (std::exception& e) {
38103       {
38104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38105       };
38106     } catch (Dali::DaliException e) {
38107       {
38108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38109       };
38110     } catch (...) {
38111       {
38112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38113       };
38114     }
38115   }
38116
38117   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
38118   return jresult;
38119 }
38120
38121
38122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
38123   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38124   bool arg2 ;
38125
38126   arg1 = (Dali::Layer *)jarg1;
38127   arg2 = jarg2 ? true : false;
38128   {
38129     try {
38130       (arg1)->SetDepthTestDisabled(arg2);
38131     } catch (std::out_of_range& e) {
38132       {
38133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38134       };
38135     } catch (std::exception& e) {
38136       {
38137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38138       };
38139     } catch (Dali::DaliException e) {
38140       {
38141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38142       };
38143     } catch (...) {
38144       {
38145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38146       };
38147     }
38148   }
38149
38150 }
38151
38152
38153 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38154   unsigned int jresult ;
38155   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38156   bool result;
38157
38158   arg1 = (Dali::Layer *)jarg1;
38159   {
38160     try {
38161       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
38162     } catch (std::out_of_range& e) {
38163       {
38164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38165       };
38166     } catch (std::exception& e) {
38167       {
38168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38169       };
38170     } catch (Dali::DaliException e) {
38171       {
38172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38173       };
38174     } catch (...) {
38175       {
38176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38177       };
38178     }
38179   }
38180
38181   jresult = result;
38182   return jresult;
38183 }
38184
38185
38186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38187   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38188   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38189
38190   arg1 = (Dali::Layer *)jarg1;
38191   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38192   {
38193     try {
38194       (arg1)->SetSortFunction(arg2);
38195     } catch (std::out_of_range& e) {
38196       {
38197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38198       };
38199     } catch (std::exception& e) {
38200       {
38201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38202       };
38203     } catch (Dali::DaliException e) {
38204       {
38205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38206       };
38207     } catch (...) {
38208       {
38209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38210       };
38211     }
38212   }
38213
38214 }
38215
38216
38217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38218   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38219   bool arg2 ;
38220
38221   arg1 = (Dali::Layer *)jarg1;
38222   arg2 = jarg2 ? true : false;
38223   {
38224     try {
38225       (arg1)->SetTouchConsumed(arg2);
38226     } catch (std::out_of_range& e) {
38227       {
38228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38229       };
38230     } catch (std::exception& e) {
38231       {
38232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38233       };
38234     } catch (Dali::DaliException e) {
38235       {
38236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38237       };
38238     } catch (...) {
38239       {
38240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38241       };
38242     }
38243   }
38244
38245 }
38246
38247
38248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38249   unsigned int jresult ;
38250   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38251   bool result;
38252
38253   arg1 = (Dali::Layer *)jarg1;
38254   {
38255     try {
38256       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38257     } catch (std::out_of_range& e) {
38258       {
38259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38260       };
38261     } catch (std::exception& e) {
38262       {
38263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38264       };
38265     } catch (Dali::DaliException e) {
38266       {
38267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38268       };
38269     } catch (...) {
38270       {
38271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38272       };
38273     }
38274   }
38275
38276   jresult = result;
38277   return jresult;
38278 }
38279
38280
38281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38282   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38283   bool arg2 ;
38284
38285   arg1 = (Dali::Layer *)jarg1;
38286   arg2 = jarg2 ? true : false;
38287   {
38288     try {
38289       (arg1)->SetHoverConsumed(arg2);
38290     } catch (std::out_of_range& e) {
38291       {
38292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38293       };
38294     } catch (std::exception& e) {
38295       {
38296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38297       };
38298     } catch (Dali::DaliException e) {
38299       {
38300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38301       };
38302     } catch (...) {
38303       {
38304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38305       };
38306     }
38307   }
38308
38309 }
38310
38311
38312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38313   unsigned int jresult ;
38314   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38315   bool result;
38316
38317   arg1 = (Dali::Layer *)jarg1;
38318   {
38319     try {
38320       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38321     } catch (std::out_of_range& e) {
38322       {
38323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38324       };
38325     } catch (std::exception& e) {
38326       {
38327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38328       };
38329     } catch (Dali::DaliException e) {
38330       {
38331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38332       };
38333     } catch (...) {
38334       {
38335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38336       };
38337     }
38338   }
38339
38340   jresult = result;
38341   return jresult;
38342 }
38343
38344
38345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38346   void * jresult ;
38347   Dali::Vector4 *result = 0 ;
38348
38349   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38350   jresult = (void *)result;
38351   return jresult;
38352 }
38353
38354
38355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38356   void * jresult ;
38357   Dali::Vector4 *result = 0 ;
38358
38359   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38360   jresult = (void *)result;
38361   return jresult;
38362 }
38363
38364
38365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38366   void * jresult ;
38367   Dali::Stage *result = 0 ;
38368
38369   {
38370     try {
38371       result = (Dali::Stage *)new Dali::Stage();
38372     } catch (std::out_of_range& e) {
38373       {
38374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38375       };
38376     } catch (std::exception& e) {
38377       {
38378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38379       };
38380     } catch (Dali::DaliException e) {
38381       {
38382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38383       };
38384     } catch (...) {
38385       {
38386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38387       };
38388     }
38389   }
38390
38391   jresult = (void *)result;
38392   return jresult;
38393 }
38394
38395
38396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38397   void * jresult ;
38398   Dali::Stage result;
38399
38400   {
38401     try {
38402       result = Dali::Stage::GetCurrent();
38403     } catch (std::out_of_range& e) {
38404       {
38405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38406       };
38407     } catch (std::exception& e) {
38408       {
38409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38410       };
38411     } catch (Dali::DaliException e) {
38412       {
38413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38414       };
38415     } catch (...) {
38416       {
38417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38418       };
38419     }
38420   }
38421
38422   jresult = new Dali::Stage((const Dali::Stage &)result);
38423   return jresult;
38424 }
38425
38426
38427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38428   unsigned int jresult ;
38429   bool result;
38430
38431   {
38432     try {
38433       result = (bool)Dali::Stage::IsInstalled();
38434     } catch (std::out_of_range& e) {
38435       {
38436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38437       };
38438     } catch (std::exception& e) {
38439       {
38440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38441       };
38442     } catch (Dali::DaliException e) {
38443       {
38444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38445       };
38446     } catch (...) {
38447       {
38448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38449       };
38450     }
38451   }
38452
38453   jresult = result;
38454   return jresult;
38455 }
38456
38457
38458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38459   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38460
38461   arg1 = (Dali::Stage *)jarg1;
38462   {
38463     try {
38464       delete arg1;
38465     } catch (std::out_of_range& e) {
38466       {
38467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38468       };
38469     } catch (std::exception& e) {
38470       {
38471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38472       };
38473     } catch (Dali::DaliException e) {
38474       {
38475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38476       };
38477     } catch (...) {
38478       {
38479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38480       };
38481     }
38482   }
38483
38484 }
38485
38486
38487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38488   void * jresult ;
38489   Dali::Stage *arg1 = 0 ;
38490   Dali::Stage *result = 0 ;
38491
38492   arg1 = (Dali::Stage *)jarg1;
38493   if (!arg1) {
38494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38495     return 0;
38496   }
38497   {
38498     try {
38499       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38500     } catch (std::out_of_range& e) {
38501       {
38502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38503       };
38504     } catch (std::exception& e) {
38505       {
38506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38507       };
38508     } catch (Dali::DaliException e) {
38509       {
38510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38511       };
38512     } catch (...) {
38513       {
38514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38515       };
38516     }
38517   }
38518
38519   jresult = (void *)result;
38520   return jresult;
38521 }
38522
38523
38524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38525   void * jresult ;
38526   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38527   Dali::Stage *arg2 = 0 ;
38528   Dali::Stage *result = 0 ;
38529
38530   arg1 = (Dali::Stage *)jarg1;
38531   arg2 = (Dali::Stage *)jarg2;
38532   if (!arg2) {
38533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38534     return 0;
38535   }
38536   {
38537     try {
38538       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38539     } catch (std::out_of_range& e) {
38540       {
38541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38542       };
38543     } catch (std::exception& e) {
38544       {
38545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38546       };
38547     } catch (Dali::DaliException e) {
38548       {
38549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38550       };
38551     } catch (...) {
38552       {
38553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38554       };
38555     }
38556   }
38557
38558   jresult = (void *)result;
38559   return jresult;
38560 }
38561
38562
38563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38564   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38565   Dali::Actor *arg2 = 0 ;
38566
38567   arg1 = (Dali::Stage *)jarg1;
38568   arg2 = (Dali::Actor *)jarg2;
38569   if (!arg2) {
38570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38571     return ;
38572   }
38573   {
38574     try {
38575       (arg1)->Add(*arg2);
38576     } catch (std::out_of_range& e) {
38577       {
38578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38579       };
38580     } catch (std::exception& e) {
38581       {
38582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38583       };
38584     } catch (Dali::DaliException e) {
38585       {
38586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38587       };
38588     } catch (...) {
38589       {
38590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38591       };
38592     }
38593   }
38594
38595 }
38596
38597
38598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38599   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38600   Dali::Actor *arg2 = 0 ;
38601
38602   arg1 = (Dali::Stage *)jarg1;
38603   arg2 = (Dali::Actor *)jarg2;
38604   if (!arg2) {
38605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38606     return ;
38607   }
38608   {
38609     try {
38610       (arg1)->Remove(*arg2);
38611     } catch (std::out_of_range& e) {
38612       {
38613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38614       };
38615     } catch (std::exception& e) {
38616       {
38617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38618       };
38619     } catch (Dali::DaliException e) {
38620       {
38621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38622       };
38623     } catch (...) {
38624       {
38625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38626       };
38627     }
38628   }
38629
38630 }
38631
38632
38633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38634   void * jresult ;
38635   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38636   Dali::Vector2 result;
38637
38638   arg1 = (Dali::Stage *)jarg1;
38639   {
38640     try {
38641       result = ((Dali::Stage const *)arg1)->GetSize();
38642     } catch (std::out_of_range& e) {
38643       {
38644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38645       };
38646     } catch (std::exception& e) {
38647       {
38648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38649       };
38650     } catch (Dali::DaliException e) {
38651       {
38652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38653       };
38654     } catch (...) {
38655       {
38656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38657       };
38658     }
38659   }
38660
38661   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38662   return jresult;
38663 }
38664
38665
38666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38667   void * jresult ;
38668   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38669   Dali::RenderTaskList result;
38670
38671   arg1 = (Dali::Stage *)jarg1;
38672   {
38673     try {
38674       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38675     } catch (std::out_of_range& e) {
38676       {
38677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38678       };
38679     } catch (std::exception& e) {
38680       {
38681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38682       };
38683     } catch (Dali::DaliException e) {
38684       {
38685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38686       };
38687     } catch (...) {
38688       {
38689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38690       };
38691     }
38692   }
38693
38694   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38695   return jresult;
38696 }
38697
38698
38699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38700   unsigned int jresult ;
38701   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38702   unsigned int result;
38703
38704   arg1 = (Dali::Stage *)jarg1;
38705   {
38706     try {
38707       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38708     } catch (std::out_of_range& e) {
38709       {
38710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38711       };
38712     } catch (std::exception& e) {
38713       {
38714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38715       };
38716     } catch (Dali::DaliException e) {
38717       {
38718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38719       };
38720     } catch (...) {
38721       {
38722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38723       };
38724     }
38725   }
38726
38727   jresult = result;
38728   return jresult;
38729 }
38730
38731
38732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38733   void * jresult ;
38734   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38735   unsigned int arg2 ;
38736   Dali::Layer result;
38737
38738   arg1 = (Dali::Stage *)jarg1;
38739   arg2 = (unsigned int)jarg2;
38740   {
38741     try {
38742       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38743     } catch (std::out_of_range& e) {
38744       {
38745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38746       };
38747     } catch (std::exception& e) {
38748       {
38749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38750       };
38751     } catch (Dali::DaliException e) {
38752       {
38753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38754       };
38755     } catch (...) {
38756       {
38757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38758       };
38759     }
38760   }
38761
38762   jresult = new Dali::Layer((const Dali::Layer &)result);
38763   return jresult;
38764 }
38765
38766
38767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38768   void * jresult ;
38769   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38770   Dali::Layer result;
38771
38772   arg1 = (Dali::Stage *)jarg1;
38773   {
38774     try {
38775       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38776     } catch (std::out_of_range& e) {
38777       {
38778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38779       };
38780     } catch (std::exception& e) {
38781       {
38782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38783       };
38784     } catch (Dali::DaliException e) {
38785       {
38786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38787       };
38788     } catch (...) {
38789       {
38790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38791       };
38792     }
38793   }
38794
38795   jresult = new Dali::Layer((const Dali::Layer &)result);
38796   return jresult;
38797 }
38798
38799
38800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38801   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38802   Dali::Vector4 arg2 ;
38803   Dali::Vector4 *argp2 ;
38804
38805   arg1 = (Dali::Stage *)jarg1;
38806   argp2 = (Dali::Vector4 *)jarg2;
38807   if (!argp2) {
38808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38809     return ;
38810   }
38811   arg2 = *argp2;
38812   {
38813     try {
38814       (arg1)->SetBackgroundColor(arg2);
38815     } catch (std::out_of_range& e) {
38816       {
38817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38818       };
38819     } catch (std::exception& e) {
38820       {
38821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38822       };
38823     } catch (Dali::DaliException e) {
38824       {
38825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38826       };
38827     } catch (...) {
38828       {
38829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38830       };
38831     }
38832   }
38833
38834 }
38835
38836
38837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38838   void * jresult ;
38839   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38840   Dali::Vector4 result;
38841
38842   arg1 = (Dali::Stage *)jarg1;
38843   {
38844     try {
38845       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38846     } catch (std::out_of_range& e) {
38847       {
38848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38849       };
38850     } catch (std::exception& e) {
38851       {
38852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38853       };
38854     } catch (Dali::DaliException e) {
38855       {
38856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38857       };
38858     } catch (...) {
38859       {
38860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38861       };
38862     }
38863   }
38864
38865   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38866   return jresult;
38867 }
38868
38869
38870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38871   void * jresult ;
38872   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38873   Dali::Vector2 result;
38874
38875   arg1 = (Dali::Stage *)jarg1;
38876   {
38877     try {
38878       result = ((Dali::Stage const *)arg1)->GetDpi();
38879     } catch (std::out_of_range& e) {
38880       {
38881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38882       };
38883     } catch (std::exception& e) {
38884       {
38885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38886       };
38887     } catch (Dali::DaliException e) {
38888       {
38889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38890       };
38891     } catch (...) {
38892       {
38893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38894       };
38895     }
38896   }
38897
38898   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38899   return jresult;
38900 }
38901
38902
38903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38904   void * jresult ;
38905   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38906   Dali::ObjectRegistry result;
38907
38908   arg1 = (Dali::Stage *)jarg1;
38909   {
38910     try {
38911       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38912     } catch (std::out_of_range& e) {
38913       {
38914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38915       };
38916     } catch (std::exception& e) {
38917       {
38918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38919       };
38920     } catch (Dali::DaliException e) {
38921       {
38922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38923       };
38924     } catch (...) {
38925       {
38926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38927       };
38928     }
38929   }
38930
38931   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38932   return jresult;
38933 }
38934
38935
38936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38937   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38938   float arg2 ;
38939
38940   arg1 = (Dali::Stage *)jarg1;
38941   arg2 = (float)jarg2;
38942   {
38943     try {
38944       (arg1)->KeepRendering(arg2);
38945     } catch (std::out_of_range& e) {
38946       {
38947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38948       };
38949     } catch (std::exception& e) {
38950       {
38951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38952       };
38953     } catch (Dali::DaliException e) {
38954       {
38955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38956       };
38957     } catch (...) {
38958       {
38959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38960       };
38961     }
38962   }
38963
38964 }
38965
38966
38967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38968   void * jresult ;
38969   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38970   Dali::Stage::KeyEventSignalType *result = 0 ;
38971
38972   arg1 = (Dali::Stage *)jarg1;
38973   {
38974     try {
38975       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38976     } catch (std::out_of_range& e) {
38977       {
38978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38979       };
38980     } catch (std::exception& e) {
38981       {
38982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38983       };
38984     } catch (Dali::DaliException e) {
38985       {
38986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38987       };
38988     } catch (...) {
38989       {
38990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38991       };
38992     }
38993   }
38994
38995   jresult = (void *)result;
38996   return jresult;
38997 }
38998
38999
39000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
39001   void * jresult ;
39002   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39003   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
39004
39005   arg1 = (Dali::Stage *)jarg1;
39006   {
39007     try {
39008       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
39009     } catch (std::out_of_range& e) {
39010       {
39011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39012       };
39013     } catch (std::exception& e) {
39014       {
39015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39016       };
39017     } catch (Dali::DaliException e) {
39018       {
39019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39020       };
39021     } catch (...) {
39022       {
39023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39024       };
39025     }
39026   }
39027
39028   jresult = (void *)result;
39029   return jresult;
39030 }
39031
39032
39033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
39034   void * jresult ;
39035   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39036   Dali::Stage::TouchSignalType *result = 0 ;
39037
39038   arg1 = (Dali::Stage *)jarg1;
39039   {
39040     try {
39041       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
39042     } catch (std::out_of_range& e) {
39043       {
39044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39045       };
39046     } catch (std::exception& e) {
39047       {
39048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39049       };
39050     } catch (Dali::DaliException e) {
39051       {
39052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39053       };
39054     } catch (...) {
39055       {
39056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39057       };
39058     }
39059   }
39060
39061   jresult = (void *)result;
39062   return jresult;
39063 }
39064
39065
39066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
39067   void * jresult ;
39068   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39069   Dali::Stage::WheelEventSignalType *result = 0 ;
39070
39071   arg1 = (Dali::Stage *)jarg1;
39072   {
39073     try {
39074       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
39075     } catch (std::out_of_range& e) {
39076       {
39077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39078       };
39079     } catch (std::exception& e) {
39080       {
39081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39082       };
39083     } catch (Dali::DaliException e) {
39084       {
39085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39086       };
39087     } catch (...) {
39088       {
39089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39090       };
39091     }
39092   }
39093
39094   jresult = (void *)result;
39095   return jresult;
39096 }
39097
39098
39099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
39100   void * jresult ;
39101   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39102   Dali::Stage::ContextStatusSignal *result = 0 ;
39103
39104   arg1 = (Dali::Stage *)jarg1;
39105   {
39106     try {
39107       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
39108     } catch (std::out_of_range& e) {
39109       {
39110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39111       };
39112     } catch (std::exception& e) {
39113       {
39114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39115       };
39116     } catch (Dali::DaliException e) {
39117       {
39118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39119       };
39120     } catch (...) {
39121       {
39122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39123       };
39124     }
39125   }
39126
39127   jresult = (void *)result;
39128   return jresult;
39129 }
39130
39131
39132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
39133   void * jresult ;
39134   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39135   Dali::Stage::ContextStatusSignal *result = 0 ;
39136
39137   arg1 = (Dali::Stage *)jarg1;
39138   {
39139     try {
39140       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
39141     } catch (std::out_of_range& e) {
39142       {
39143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39144       };
39145     } catch (std::exception& e) {
39146       {
39147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39148       };
39149     } catch (Dali::DaliException e) {
39150       {
39151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39152       };
39153     } catch (...) {
39154       {
39155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39156       };
39157     }
39158   }
39159
39160   jresult = (void *)result;
39161   return jresult;
39162 }
39163
39164
39165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
39166   void * jresult ;
39167   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39168   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39169
39170   arg1 = (Dali::Stage *)jarg1;
39171   {
39172     try {
39173       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39174     } catch (std::out_of_range& e) {
39175       {
39176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39177       };
39178     } catch (std::exception& e) {
39179       {
39180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39181       };
39182     } catch (Dali::DaliException e) {
39183       {
39184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39185       };
39186     } catch (...) {
39187       {
39188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39189       };
39190     }
39191   }
39192
39193   jresult = (void *)result;
39194   return jresult;
39195 }
39196
39197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
39198   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39199   Dali::DevelStage::Rendering arg2 ;
39200
39201   arg1 = (Dali::Stage *)jarg1;
39202   arg2 = (Dali::DevelStage::Rendering)jarg2;
39203   {
39204     try {
39205       DevelStage::SetRenderingBehavior(*arg1,arg2);
39206     } catch (std::out_of_range& e) {
39207       {
39208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39209       };
39210     } catch (std::exception& e) {
39211       {
39212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39213       };
39214     } catch (Dali::DaliException e) {
39215       {
39216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39217       };
39218     } catch (...) {
39219       {
39220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39221       };
39222     }
39223   }
39224
39225 }
39226
39227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
39228
39229   int jresult ;
39230   int result ;
39231   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39232
39233   arg1 = (Dali::Stage *)jarg1;
39234   {
39235     try {
39236       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
39237     } catch (std::out_of_range& e) {
39238       {
39239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39240       };
39241     } catch (std::exception& e) {
39242       {
39243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39244       };
39245     } catch (Dali::DaliException e) {
39246       {
39247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39248       };
39249     } catch (...) {
39250       {
39251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39252       };
39253     }
39254   }
39255
39256   jresult = result;
39257   return jresult;
39258 }
39259
39260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39261   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39262
39263   arg1 = (Dali::RelayoutContainer *)jarg1;
39264   {
39265     try {
39266       delete arg1;
39267     } catch (std::out_of_range& e) {
39268       {
39269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39270       };
39271     } catch (std::exception& e) {
39272       {
39273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39274       };
39275     } catch (Dali::DaliException e) {
39276       {
39277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39278       };
39279     } catch (...) {
39280       {
39281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39282       };
39283     }
39284   }
39285
39286 }
39287
39288
39289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39290   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39291   Dali::Actor *arg2 = 0 ;
39292   Dali::Vector2 *arg3 = 0 ;
39293
39294   arg1 = (Dali::RelayoutContainer *)jarg1;
39295   arg2 = (Dali::Actor *)jarg2;
39296   if (!arg2) {
39297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39298     return ;
39299   }
39300   arg3 = (Dali::Vector2 *)jarg3;
39301   if (!arg3) {
39302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39303     return ;
39304   }
39305   {
39306     try {
39307       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39308     } catch (std::out_of_range& e) {
39309       {
39310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39311       };
39312     } catch (std::exception& e) {
39313       {
39314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39315       };
39316     } catch (Dali::DaliException e) {
39317       {
39318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39319       };
39320     } catch (...) {
39321       {
39322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39323       };
39324     }
39325   }
39326
39327 }
39328
39329
39330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39331   void * jresult ;
39332   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39333   Dali::CustomActor result;
39334
39335   arg1 = (Dali::CustomActorImpl *)jarg1;
39336   {
39337     try {
39338       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39339     } catch (std::out_of_range& e) {
39340       {
39341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39342       };
39343     } catch (std::exception& e) {
39344       {
39345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39346       };
39347     } catch (Dali::DaliException e) {
39348       {
39349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39350       };
39351     } catch (...) {
39352       {
39353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39354       };
39355     }
39356   }
39357
39358   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39359   return jresult;
39360 }
39361
39362
39363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39364   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39365   int arg2 ;
39366
39367   arg1 = (Dali::CustomActorImpl *)jarg1;
39368   arg2 = (int)jarg2;
39369   {
39370     try {
39371       (arg1)->OnStageConnection(arg2);
39372     } catch (std::out_of_range& e) {
39373       {
39374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39375       };
39376     } catch (std::exception& e) {
39377       {
39378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39379       };
39380     } catch (Dali::DaliException e) {
39381       {
39382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39383       };
39384     } catch (...) {
39385       {
39386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39387       };
39388     }
39389   }
39390
39391 }
39392
39393
39394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39395   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39396
39397   arg1 = (Dali::CustomActorImpl *)jarg1;
39398   {
39399     try {
39400       (arg1)->OnStageDisconnection();
39401     } catch (std::out_of_range& e) {
39402       {
39403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39404       };
39405     } catch (std::exception& e) {
39406       {
39407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39408       };
39409     } catch (Dali::DaliException e) {
39410       {
39411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39412       };
39413     } catch (...) {
39414       {
39415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39416       };
39417     }
39418   }
39419
39420 }
39421
39422
39423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39424   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39425   Dali::Actor *arg2 = 0 ;
39426
39427   arg1 = (Dali::CustomActorImpl *)jarg1;
39428   arg2 = (Dali::Actor *)jarg2;
39429   if (!arg2) {
39430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39431     return ;
39432   }
39433   {
39434     try {
39435       (arg1)->OnChildAdd(*arg2);
39436     } catch (std::out_of_range& e) {
39437       {
39438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39439       };
39440     } catch (std::exception& e) {
39441       {
39442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39443       };
39444     } catch (Dali::DaliException e) {
39445       {
39446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39447       };
39448     } catch (...) {
39449       {
39450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39451       };
39452     }
39453   }
39454
39455 }
39456
39457
39458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39459   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39460   Dali::Actor *arg2 = 0 ;
39461
39462   arg1 = (Dali::CustomActorImpl *)jarg1;
39463   arg2 = (Dali::Actor *)jarg2;
39464   if (!arg2) {
39465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39466     return ;
39467   }
39468   {
39469     try {
39470       (arg1)->OnChildRemove(*arg2);
39471     } catch (std::out_of_range& e) {
39472       {
39473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39474       };
39475     } catch (std::exception& e) {
39476       {
39477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39478       };
39479     } catch (Dali::DaliException e) {
39480       {
39481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39482       };
39483     } catch (...) {
39484       {
39485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39486       };
39487     }
39488   }
39489
39490 }
39491
39492
39493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39494   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39495   Dali::Property::Index arg2 ;
39496   Dali::Property::Value arg3 ;
39497   Dali::Property::Value *argp3 ;
39498
39499   arg1 = (Dali::CustomActorImpl *)jarg1;
39500   arg2 = (Dali::Property::Index)jarg2;
39501   argp3 = (Dali::Property::Value *)jarg3;
39502   if (!argp3) {
39503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39504     return ;
39505   }
39506   arg3 = *argp3;
39507   {
39508     try {
39509       (arg1)->OnPropertySet(arg2,arg3);
39510     } catch (std::out_of_range& e) {
39511       {
39512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39513       };
39514     } catch (std::exception& e) {
39515       {
39516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39517       };
39518     } catch (Dali::DaliException e) {
39519       {
39520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39521       };
39522     } catch (...) {
39523       {
39524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39525       };
39526     }
39527   }
39528
39529 }
39530
39531
39532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39533   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39534   Dali::Vector3 *arg2 = 0 ;
39535
39536   arg1 = (Dali::CustomActorImpl *)jarg1;
39537   arg2 = (Dali::Vector3 *)jarg2;
39538   if (!arg2) {
39539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39540     return ;
39541   }
39542   {
39543     try {
39544       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39545     } catch (std::out_of_range& e) {
39546       {
39547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39548       };
39549     } catch (std::exception& e) {
39550       {
39551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39552       };
39553     } catch (Dali::DaliException e) {
39554       {
39555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39556       };
39557     } catch (...) {
39558       {
39559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39560       };
39561     }
39562   }
39563
39564 }
39565
39566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39567   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39568   Dali::Animation *arg2 = 0 ;
39569   Dali::Vector3 *arg3 = 0 ;
39570
39571   arg1 = (Dali::CustomActorImpl *)jarg1;
39572   arg2 = (Dali::Animation *)jarg2;
39573   if (!arg2) {
39574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39575     return ;
39576   }
39577   arg3 = (Dali::Vector3 *)jarg3;
39578   if (!arg3) {
39579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39580     return ;
39581   }
39582   {
39583     try {
39584       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39585     } catch (std::out_of_range& e) {
39586       {
39587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39588       };
39589     } catch (std::exception& e) {
39590       {
39591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39592       };
39593     } catch (Dali::DaliException e) {
39594       {
39595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39596       };
39597     } catch (...) {
39598       {
39599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39600       };
39601     }
39602   }
39603
39604 }
39605
39606
39607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39608   unsigned int jresult ;
39609   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39610   Dali::TouchEvent *arg2 = 0 ;
39611   bool result;
39612
39613   arg1 = (Dali::CustomActorImpl *)jarg1;
39614   arg2 = (Dali::TouchEvent *)jarg2;
39615   if (!arg2) {
39616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39617     return 0;
39618   }
39619   {
39620     try {
39621       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39622     } catch (std::out_of_range& e) {
39623       {
39624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39625       };
39626     } catch (std::exception& e) {
39627       {
39628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39629       };
39630     } catch (Dali::DaliException e) {
39631       {
39632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39633       };
39634     } catch (...) {
39635       {
39636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39637       };
39638     }
39639   }
39640
39641   jresult = result;
39642   return jresult;
39643 }
39644
39645
39646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39647   unsigned int jresult ;
39648   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39649   Dali::HoverEvent *arg2 = 0 ;
39650   bool result;
39651
39652   arg1 = (Dali::CustomActorImpl *)jarg1;
39653   arg2 = (Dali::HoverEvent *)jarg2;
39654   if (!arg2) {
39655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39656     return 0;
39657   }
39658   {
39659     try {
39660       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39661     } catch (std::out_of_range& e) {
39662       {
39663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39664       };
39665     } catch (std::exception& e) {
39666       {
39667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39668       };
39669     } catch (Dali::DaliException e) {
39670       {
39671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39672       };
39673     } catch (...) {
39674       {
39675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39676       };
39677     }
39678   }
39679
39680   jresult = result;
39681   return jresult;
39682 }
39683
39684
39685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39686   unsigned int jresult ;
39687   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39688   Dali::KeyEvent *arg2 = 0 ;
39689   bool result;
39690
39691   arg1 = (Dali::CustomActorImpl *)jarg1;
39692   arg2 = (Dali::KeyEvent *)jarg2;
39693   if (!arg2) {
39694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39695     return 0;
39696   }
39697   {
39698     try {
39699       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39700     } catch (std::out_of_range& e) {
39701       {
39702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39703       };
39704     } catch (std::exception& e) {
39705       {
39706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39707       };
39708     } catch (Dali::DaliException e) {
39709       {
39710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39711       };
39712     } catch (...) {
39713       {
39714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39715       };
39716     }
39717   }
39718
39719   jresult = result;
39720   return jresult;
39721 }
39722
39723
39724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39725   unsigned int jresult ;
39726   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39727   Dali::WheelEvent *arg2 = 0 ;
39728   bool result;
39729
39730   arg1 = (Dali::CustomActorImpl *)jarg1;
39731   arg2 = (Dali::WheelEvent *)jarg2;
39732   if (!arg2) {
39733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39734     return 0;
39735   }
39736   {
39737     try {
39738       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39739     } catch (std::out_of_range& e) {
39740       {
39741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39742       };
39743     } catch (std::exception& e) {
39744       {
39745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39746       };
39747     } catch (Dali::DaliException e) {
39748       {
39749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39750       };
39751     } catch (...) {
39752       {
39753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39754       };
39755     }
39756   }
39757
39758   jresult = result;
39759   return jresult;
39760 }
39761
39762
39763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39764   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39765   Dali::Vector2 *arg2 = 0 ;
39766   Dali::RelayoutContainer *arg3 = 0 ;
39767
39768   arg1 = (Dali::CustomActorImpl *)jarg1;
39769   arg2 = (Dali::Vector2 *)jarg2;
39770   if (!arg2) {
39771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39772     return ;
39773   }
39774   arg3 = (Dali::RelayoutContainer *)jarg3;
39775   if (!arg3) {
39776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39777     return ;
39778   }
39779   {
39780     try {
39781       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39782     } catch (std::out_of_range& e) {
39783       {
39784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39785       };
39786     } catch (std::exception& e) {
39787       {
39788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39789       };
39790     } catch (Dali::DaliException e) {
39791       {
39792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39793       };
39794     } catch (...) {
39795       {
39796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39797       };
39798     }
39799   }
39800
39801 }
39802
39803
39804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39805   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39806   Dali::ResizePolicy::Type arg2 ;
39807   Dali::Dimension::Type arg3 ;
39808
39809   arg1 = (Dali::CustomActorImpl *)jarg1;
39810   arg2 = (Dali::ResizePolicy::Type)jarg2;
39811   arg3 = (Dali::Dimension::Type)jarg3;
39812   {
39813     try {
39814       (arg1)->OnSetResizePolicy(arg2,arg3);
39815     } catch (std::out_of_range& e) {
39816       {
39817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39818       };
39819     } catch (std::exception& e) {
39820       {
39821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39822       };
39823     } catch (Dali::DaliException e) {
39824       {
39825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39826       };
39827     } catch (...) {
39828       {
39829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39830       };
39831     }
39832   }
39833
39834 }
39835
39836
39837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39838   void * jresult ;
39839   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39840   Dali::Vector3 result;
39841
39842   arg1 = (Dali::CustomActorImpl *)jarg1;
39843   {
39844     try {
39845       result = (arg1)->GetNaturalSize();
39846     } catch (std::out_of_range& e) {
39847       {
39848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39849       };
39850     } catch (std::exception& e) {
39851       {
39852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39853       };
39854     } catch (Dali::DaliException e) {
39855       {
39856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39857       };
39858     } catch (...) {
39859       {
39860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39861       };
39862     }
39863   }
39864
39865   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39866   return jresult;
39867 }
39868
39869
39870 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39871   float jresult ;
39872   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39873   Dali::Actor *arg2 = 0 ;
39874   Dali::Dimension::Type arg3 ;
39875   float result;
39876
39877   arg1 = (Dali::CustomActorImpl *)jarg1;
39878   arg2 = (Dali::Actor *)jarg2;
39879   if (!arg2) {
39880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39881     return 0;
39882   }
39883   arg3 = (Dali::Dimension::Type)jarg3;
39884   {
39885     try {
39886       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39887     } catch (std::out_of_range& e) {
39888       {
39889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39890       };
39891     } catch (std::exception& e) {
39892       {
39893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39894       };
39895     } catch (Dali::DaliException e) {
39896       {
39897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39898       };
39899     } catch (...) {
39900       {
39901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39902       };
39903     }
39904   }
39905
39906   jresult = result;
39907   return jresult;
39908 }
39909
39910
39911 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39912   float jresult ;
39913   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39914   float arg2 ;
39915   float result;
39916
39917   arg1 = (Dali::CustomActorImpl *)jarg1;
39918   arg2 = (float)jarg2;
39919   {
39920     try {
39921       result = (float)(arg1)->GetHeightForWidth(arg2);
39922     } catch (std::out_of_range& e) {
39923       {
39924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39925       };
39926     } catch (std::exception& e) {
39927       {
39928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39929       };
39930     } catch (Dali::DaliException e) {
39931       {
39932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39933       };
39934     } catch (...) {
39935       {
39936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39937       };
39938     }
39939   }
39940
39941   jresult = result;
39942   return jresult;
39943 }
39944
39945
39946 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39947   float jresult ;
39948   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39949   float arg2 ;
39950   float result;
39951
39952   arg1 = (Dali::CustomActorImpl *)jarg1;
39953   arg2 = (float)jarg2;
39954   {
39955     try {
39956       result = (float)(arg1)->GetWidthForHeight(arg2);
39957     } catch (std::out_of_range& e) {
39958       {
39959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39960       };
39961     } catch (std::exception& e) {
39962       {
39963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39964       };
39965     } catch (Dali::DaliException e) {
39966       {
39967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39968       };
39969     } catch (...) {
39970       {
39971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39972       };
39973     }
39974   }
39975
39976   jresult = result;
39977   return jresult;
39978 }
39979
39980
39981 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39982   unsigned int jresult ;
39983   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39984   Dali::Dimension::Type arg2 ;
39985   bool result;
39986
39987   arg1 = (Dali::CustomActorImpl *)jarg1;
39988   arg2 = (Dali::Dimension::Type)jarg2;
39989   {
39990     try {
39991       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39992     } catch (std::out_of_range& e) {
39993       {
39994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39995       };
39996     } catch (std::exception& e) {
39997       {
39998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39999       };
40000     } catch (Dali::DaliException e) {
40001       {
40002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40003       };
40004     } catch (...) {
40005       {
40006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40007       };
40008     }
40009   }
40010
40011   jresult = result;
40012   return jresult;
40013 }
40014
40015
40016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
40017   unsigned int jresult ;
40018   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40019   bool result;
40020
40021   arg1 = (Dali::CustomActorImpl *)jarg1;
40022   {
40023     try {
40024       result = (bool)(arg1)->RelayoutDependentOnChildren();
40025     } catch (std::out_of_range& e) {
40026       {
40027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40028       };
40029     } catch (std::exception& e) {
40030       {
40031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40032       };
40033     } catch (Dali::DaliException e) {
40034       {
40035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40036       };
40037     } catch (...) {
40038       {
40039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40040       };
40041     }
40042   }
40043
40044   jresult = result;
40045   return jresult;
40046 }
40047
40048
40049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
40050   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40051   Dali::Dimension::Type arg2 ;
40052
40053   arg1 = (Dali::CustomActorImpl *)jarg1;
40054   arg2 = (Dali::Dimension::Type)jarg2;
40055   {
40056     try {
40057       (arg1)->OnCalculateRelayoutSize(arg2);
40058     } catch (std::out_of_range& e) {
40059       {
40060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40061       };
40062     } catch (std::exception& e) {
40063       {
40064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40065       };
40066     } catch (Dali::DaliException e) {
40067       {
40068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40069       };
40070     } catch (...) {
40071       {
40072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40073       };
40074     }
40075   }
40076
40077 }
40078
40079
40080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
40081   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40082   float arg2 ;
40083   Dali::Dimension::Type arg3 ;
40084
40085   arg1 = (Dali::CustomActorImpl *)jarg1;
40086   arg2 = (float)jarg2;
40087   arg3 = (Dali::Dimension::Type)jarg3;
40088   {
40089     try {
40090       (arg1)->OnLayoutNegotiated(arg2,arg3);
40091     } catch (std::out_of_range& e) {
40092       {
40093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40094       };
40095     } catch (std::exception& e) {
40096       {
40097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40098       };
40099     } catch (Dali::DaliException e) {
40100       {
40101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40102       };
40103     } catch (...) {
40104       {
40105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40106       };
40107     }
40108   }
40109
40110 }
40111
40112
40113 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
40114   unsigned int jresult ;
40115   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40116   bool result;
40117
40118   arg1 = (Dali::CustomActorImpl *)jarg1;
40119   {
40120     try {
40121       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
40122     } catch (std::out_of_range& e) {
40123       {
40124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40125       };
40126     } catch (std::exception& e) {
40127       {
40128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40129       };
40130     } catch (Dali::DaliException e) {
40131       {
40132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40133       };
40134     } catch (...) {
40135       {
40136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40137       };
40138     }
40139   }
40140
40141   jresult = result;
40142   return jresult;
40143 }
40144
40145
40146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
40147   unsigned int jresult ;
40148   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40149   bool result;
40150
40151   arg1 = (Dali::CustomActorImpl *)jarg1;
40152   {
40153     try {
40154       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
40155     } catch (std::out_of_range& e) {
40156       {
40157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40158       };
40159     } catch (std::exception& e) {
40160       {
40161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40162       };
40163     } catch (Dali::DaliException e) {
40164       {
40165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40166       };
40167     } catch (...) {
40168       {
40169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40170       };
40171     }
40172   }
40173
40174   jresult = result;
40175   return jresult;
40176 }
40177
40178
40179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40180   unsigned int jresult ;
40181   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40182   bool result;
40183
40184   arg1 = (Dali::CustomActorImpl *)jarg1;
40185   {
40186     try {
40187       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40188     } catch (std::out_of_range& e) {
40189       {
40190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40191       };
40192     } catch (std::exception& e) {
40193       {
40194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40195       };
40196     } catch (Dali::DaliException e) {
40197       {
40198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40199       };
40200     } catch (...) {
40201       {
40202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40203       };
40204     }
40205   }
40206
40207   jresult = result;
40208   return jresult;
40209 }
40210
40211
40212 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40213   unsigned int jresult ;
40214   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40215   bool result;
40216
40217   arg1 = (Dali::CustomActorImpl *)jarg1;
40218   {
40219     try {
40220       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40221     } catch (std::out_of_range& e) {
40222       {
40223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40224       };
40225     } catch (std::exception& e) {
40226       {
40227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40228       };
40229     } catch (Dali::DaliException e) {
40230       {
40231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40232       };
40233     } catch (...) {
40234       {
40235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40236       };
40237     }
40238   }
40239
40240   jresult = result;
40241   return jresult;
40242 }
40243
40244
40245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40246   void * jresult ;
40247   Dali::CustomActor *result = 0 ;
40248
40249   {
40250     try {
40251       result = (Dali::CustomActor *)new Dali::CustomActor();
40252     } catch (std::out_of_range& e) {
40253       {
40254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40255       };
40256     } catch (std::exception& e) {
40257       {
40258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40259       };
40260     } catch (Dali::DaliException e) {
40261       {
40262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40263       };
40264     } catch (...) {
40265       {
40266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40267       };
40268     }
40269   }
40270
40271   jresult = (void *)result;
40272   return jresult;
40273 }
40274
40275
40276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40277   void * jresult ;
40278   Dali::BaseHandle arg1 ;
40279   Dali::BaseHandle *argp1 ;
40280   Dali::CustomActor result;
40281
40282   argp1 = (Dali::BaseHandle *)jarg1;
40283   if (!argp1) {
40284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40285     return 0;
40286   }
40287   arg1 = *argp1;
40288   {
40289     try {
40290       result = Dali::CustomActor::DownCast(arg1);
40291     } catch (std::out_of_range& e) {
40292       {
40293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40294       };
40295     } catch (std::exception& e) {
40296       {
40297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40298       };
40299     } catch (Dali::DaliException e) {
40300       {
40301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40302       };
40303     } catch (...) {
40304       {
40305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40306       };
40307     }
40308   }
40309
40310   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40311   return jresult;
40312 }
40313
40314
40315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40316   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40317
40318   arg1 = (Dali::CustomActor *)jarg1;
40319   {
40320     try {
40321       delete arg1;
40322     } catch (std::out_of_range& e) {
40323       {
40324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40325       };
40326     } catch (std::exception& e) {
40327       {
40328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40329       };
40330     } catch (Dali::DaliException e) {
40331       {
40332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40333       };
40334     } catch (...) {
40335       {
40336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40337       };
40338     }
40339   }
40340
40341 }
40342
40343
40344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40345   void * jresult ;
40346   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40347   Dali::CustomActorImpl *result = 0 ;
40348
40349   arg1 = (Dali::CustomActor *)jarg1;
40350   {
40351     try {
40352       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40353     } catch (std::out_of_range& e) {
40354       {
40355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40356       };
40357     } catch (std::exception& e) {
40358       {
40359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40360       };
40361     } catch (Dali::DaliException e) {
40362       {
40363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40364       };
40365     } catch (...) {
40366       {
40367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40368       };
40369     }
40370   }
40371
40372   jresult = (void *)result;
40373   return jresult;
40374 }
40375
40376
40377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40378   void * jresult ;
40379   Dali::CustomActorImpl *arg1 = 0 ;
40380   Dali::CustomActor *result = 0 ;
40381
40382   arg1 = (Dali::CustomActorImpl *)jarg1;
40383   if (!arg1) {
40384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40385     return 0;
40386   }
40387   {
40388     try {
40389       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40390     } catch (std::out_of_range& e) {
40391       {
40392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40393       };
40394     } catch (std::exception& e) {
40395       {
40396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40397       };
40398     } catch (Dali::DaliException e) {
40399       {
40400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40401       };
40402     } catch (...) {
40403       {
40404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40405       };
40406     }
40407   }
40408
40409   jresult = (void *)result;
40410   return jresult;
40411 }
40412
40413
40414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40415   void * jresult ;
40416   Dali::CustomActor *arg1 = 0 ;
40417   Dali::CustomActor *result = 0 ;
40418
40419   arg1 = (Dali::CustomActor *)jarg1;
40420   if (!arg1) {
40421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40422     return 0;
40423   }
40424   {
40425     try {
40426       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40427     } catch (std::out_of_range& e) {
40428       {
40429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40430       };
40431     } catch (std::exception& e) {
40432       {
40433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40434       };
40435     } catch (Dali::DaliException e) {
40436       {
40437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40438       };
40439     } catch (...) {
40440       {
40441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40442       };
40443     }
40444   }
40445
40446   jresult = (void *)result;
40447   return jresult;
40448 }
40449
40450
40451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40452   void * jresult ;
40453   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40454   Dali::CustomActor *arg2 = 0 ;
40455   Dali::CustomActor *result = 0 ;
40456
40457   arg1 = (Dali::CustomActor *)jarg1;
40458   arg2 = (Dali::CustomActor *)jarg2;
40459   if (!arg2) {
40460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40461     return 0;
40462   }
40463   {
40464     try {
40465       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40466     } catch (std::out_of_range& e) {
40467       {
40468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40469       };
40470     } catch (std::exception& e) {
40471       {
40472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40473       };
40474     } catch (Dali::DaliException e) {
40475       {
40476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40477       };
40478     } catch (...) {
40479       {
40480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40481       };
40482     }
40483   }
40484
40485   jresult = (void *)result;
40486   return jresult;
40487 }
40488
40489
40490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40491   int jresult ;
40492   int result;
40493
40494   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40495   jresult = (int)result;
40496   return jresult;
40497 }
40498
40499
40500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40501   int jresult ;
40502   int result;
40503
40504   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40505   jresult = (int)result;
40506   return jresult;
40507 }
40508
40509
40510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40511   int jresult ;
40512   int result;
40513
40514   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40515   jresult = (int)result;
40516   return jresult;
40517 }
40518
40519
40520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40521   int jresult ;
40522   int result;
40523
40524   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40525   jresult = (int)result;
40526   return jresult;
40527 }
40528
40529
40530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40531   int jresult ;
40532   int result;
40533
40534   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40535   jresult = (int)result;
40536   return jresult;
40537 }
40538
40539
40540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40541   int jresult ;
40542   int result;
40543
40544   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40545   jresult = (int)result;
40546   return jresult;
40547 }
40548
40549
40550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40551   int jresult ;
40552   int result;
40553
40554   result = (int)Dali::PanGestureDetector::Property::PANNING;
40555   jresult = (int)result;
40556   return jresult;
40557 }
40558
40559
40560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40561   void * jresult ;
40562   Dali::PanGestureDetector::Property *result = 0 ;
40563
40564   {
40565     try {
40566       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40567     } catch (std::out_of_range& e) {
40568       {
40569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40570       };
40571     } catch (std::exception& e) {
40572       {
40573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40574       };
40575     } catch (Dali::DaliException e) {
40576       {
40577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40578       };
40579     } catch (...) {
40580       {
40581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40582       };
40583     }
40584   }
40585
40586   jresult = (void *)result;
40587   return jresult;
40588 }
40589
40590
40591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40592   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40593
40594   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40595   {
40596     try {
40597       delete arg1;
40598     } catch (std::out_of_range& e) {
40599       {
40600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40601       };
40602     } catch (std::exception& e) {
40603       {
40604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40605       };
40606     } catch (Dali::DaliException e) {
40607       {
40608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40609       };
40610     } catch (...) {
40611       {
40612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40613       };
40614     }
40615   }
40616
40617 }
40618
40619
40620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40621   void * jresult ;
40622   Dali::Radian *result = 0 ;
40623
40624   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40625   jresult = (void *)result;
40626   return jresult;
40627 }
40628
40629
40630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40631   void * jresult ;
40632   Dali::Radian *result = 0 ;
40633
40634   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40635   jresult = (void *)result;
40636   return jresult;
40637 }
40638
40639
40640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40641   void * jresult ;
40642   Dali::Radian *result = 0 ;
40643
40644   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40645   jresult = (void *)result;
40646   return jresult;
40647 }
40648
40649
40650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40651   void * jresult ;
40652   Dali::Radian *result = 0 ;
40653
40654   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40655   jresult = (void *)result;
40656   return jresult;
40657 }
40658
40659
40660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40661   void * jresult ;
40662   Dali::Radian *result = 0 ;
40663
40664   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40665   jresult = (void *)result;
40666   return jresult;
40667 }
40668
40669
40670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40671   void * jresult ;
40672   Dali::Radian *result = 0 ;
40673
40674   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40675   jresult = (void *)result;
40676   return jresult;
40677 }
40678
40679
40680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40681   void * jresult ;
40682   Dali::Radian *result = 0 ;
40683
40684   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40685   jresult = (void *)result;
40686   return jresult;
40687 }
40688
40689
40690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40691   void * jresult ;
40692   Dali::PanGestureDetector *result = 0 ;
40693
40694   {
40695     try {
40696       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40697     } catch (std::out_of_range& e) {
40698       {
40699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40700       };
40701     } catch (std::exception& e) {
40702       {
40703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40704       };
40705     } catch (Dali::DaliException e) {
40706       {
40707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40708       };
40709     } catch (...) {
40710       {
40711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40712       };
40713     }
40714   }
40715
40716   jresult = (void *)result;
40717   return jresult;
40718 }
40719
40720
40721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40722   void * jresult ;
40723   Dali::PanGestureDetector result;
40724
40725   {
40726     try {
40727       result = Dali::PanGestureDetector::New();
40728     } catch (std::out_of_range& e) {
40729       {
40730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40731       };
40732     } catch (std::exception& e) {
40733       {
40734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40735       };
40736     } catch (Dali::DaliException e) {
40737       {
40738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40739       };
40740     } catch (...) {
40741       {
40742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40743       };
40744     }
40745   }
40746
40747   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40748   return jresult;
40749 }
40750
40751
40752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40753   void * jresult ;
40754   Dali::BaseHandle arg1 ;
40755   Dali::BaseHandle *argp1 ;
40756   Dali::PanGestureDetector result;
40757
40758   argp1 = (Dali::BaseHandle *)jarg1;
40759   if (!argp1) {
40760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40761     return 0;
40762   }
40763   arg1 = *argp1;
40764   {
40765     try {
40766       result = Dali::PanGestureDetector::DownCast(arg1);
40767     } catch (std::out_of_range& e) {
40768       {
40769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40770       };
40771     } catch (std::exception& e) {
40772       {
40773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40774       };
40775     } catch (Dali::DaliException e) {
40776       {
40777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40778       };
40779     } catch (...) {
40780       {
40781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40782       };
40783     }
40784   }
40785
40786   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40787   return jresult;
40788 }
40789
40790
40791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40792   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40793
40794   arg1 = (Dali::PanGestureDetector *)jarg1;
40795   {
40796     try {
40797       delete arg1;
40798     } catch (std::out_of_range& e) {
40799       {
40800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40801       };
40802     } catch (std::exception& e) {
40803       {
40804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40805       };
40806     } catch (Dali::DaliException e) {
40807       {
40808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40809       };
40810     } catch (...) {
40811       {
40812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40813       };
40814     }
40815   }
40816
40817 }
40818
40819
40820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40821   void * jresult ;
40822   Dali::PanGestureDetector *arg1 = 0 ;
40823   Dali::PanGestureDetector *result = 0 ;
40824
40825   arg1 = (Dali::PanGestureDetector *)jarg1;
40826   if (!arg1) {
40827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40828     return 0;
40829   }
40830   {
40831     try {
40832       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40833     } catch (std::out_of_range& e) {
40834       {
40835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40836       };
40837     } catch (std::exception& e) {
40838       {
40839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40840       };
40841     } catch (Dali::DaliException e) {
40842       {
40843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40844       };
40845     } catch (...) {
40846       {
40847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40848       };
40849     }
40850   }
40851
40852   jresult = (void *)result;
40853   return jresult;
40854 }
40855
40856
40857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40858   void * jresult ;
40859   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40860   Dali::PanGestureDetector *arg2 = 0 ;
40861   Dali::PanGestureDetector *result = 0 ;
40862
40863   arg1 = (Dali::PanGestureDetector *)jarg1;
40864   arg2 = (Dali::PanGestureDetector *)jarg2;
40865   if (!arg2) {
40866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40867     return 0;
40868   }
40869   {
40870     try {
40871       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40872     } catch (std::out_of_range& e) {
40873       {
40874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40875       };
40876     } catch (std::exception& e) {
40877       {
40878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40879       };
40880     } catch (Dali::DaliException e) {
40881       {
40882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40883       };
40884     } catch (...) {
40885       {
40886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40887       };
40888     }
40889   }
40890
40891   jresult = (void *)result;
40892   return jresult;
40893 }
40894
40895
40896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40897   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40898   unsigned int arg2 ;
40899
40900   arg1 = (Dali::PanGestureDetector *)jarg1;
40901   arg2 = (unsigned int)jarg2;
40902   {
40903     try {
40904       (arg1)->SetMinimumTouchesRequired(arg2);
40905     } catch (std::out_of_range& e) {
40906       {
40907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40908       };
40909     } catch (std::exception& e) {
40910       {
40911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40912       };
40913     } catch (Dali::DaliException e) {
40914       {
40915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40916       };
40917     } catch (...) {
40918       {
40919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40920       };
40921     }
40922   }
40923
40924 }
40925
40926
40927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40928   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40929   unsigned int arg2 ;
40930
40931   arg1 = (Dali::PanGestureDetector *)jarg1;
40932   arg2 = (unsigned int)jarg2;
40933   {
40934     try {
40935       (arg1)->SetMaximumTouchesRequired(arg2);
40936     } catch (std::out_of_range& e) {
40937       {
40938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40939       };
40940     } catch (std::exception& e) {
40941       {
40942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40943       };
40944     } catch (Dali::DaliException e) {
40945       {
40946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40947       };
40948     } catch (...) {
40949       {
40950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40951       };
40952     }
40953   }
40954
40955 }
40956
40957
40958 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40959   unsigned int jresult ;
40960   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40961   unsigned int result;
40962
40963   arg1 = (Dali::PanGestureDetector *)jarg1;
40964   {
40965     try {
40966       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40967     } catch (std::out_of_range& e) {
40968       {
40969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40970       };
40971     } catch (std::exception& e) {
40972       {
40973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40974       };
40975     } catch (Dali::DaliException e) {
40976       {
40977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40978       };
40979     } catch (...) {
40980       {
40981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40982       };
40983     }
40984   }
40985
40986   jresult = result;
40987   return jresult;
40988 }
40989
40990
40991 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40992   unsigned int jresult ;
40993   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40994   unsigned int result;
40995
40996   arg1 = (Dali::PanGestureDetector *)jarg1;
40997   {
40998     try {
40999       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
41000     } catch (std::out_of_range& e) {
41001       {
41002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41003       };
41004     } catch (std::exception& e) {
41005       {
41006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41007       };
41008     } catch (Dali::DaliException e) {
41009       {
41010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41011       };
41012     } catch (...) {
41013       {
41014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41015       };
41016     }
41017   }
41018
41019   jresult = result;
41020   return jresult;
41021 }
41022
41023
41024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
41025   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41026   Dali::Radian arg2 ;
41027   Dali::Radian arg3 ;
41028   Dali::Radian *argp2 ;
41029   Dali::Radian *argp3 ;
41030
41031   arg1 = (Dali::PanGestureDetector *)jarg1;
41032   argp2 = (Dali::Radian *)jarg2;
41033   if (!argp2) {
41034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41035     return ;
41036   }
41037   arg2 = *argp2;
41038   argp3 = (Dali::Radian *)jarg3;
41039   if (!argp3) {
41040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41041     return ;
41042   }
41043   arg3 = *argp3;
41044   {
41045     try {
41046       (arg1)->AddAngle(arg2,arg3);
41047     } catch (std::out_of_range& e) {
41048       {
41049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41050       };
41051     } catch (std::exception& e) {
41052       {
41053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41054       };
41055     } catch (Dali::DaliException e) {
41056       {
41057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41058       };
41059     } catch (...) {
41060       {
41061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41062       };
41063     }
41064   }
41065
41066 }
41067
41068
41069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
41070   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41071   Dali::Radian arg2 ;
41072   Dali::Radian *argp2 ;
41073
41074   arg1 = (Dali::PanGestureDetector *)jarg1;
41075   argp2 = (Dali::Radian *)jarg2;
41076   if (!argp2) {
41077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41078     return ;
41079   }
41080   arg2 = *argp2;
41081   {
41082     try {
41083       (arg1)->AddAngle(arg2);
41084     } catch (std::out_of_range& e) {
41085       {
41086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41087       };
41088     } catch (std::exception& e) {
41089       {
41090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41091       };
41092     } catch (Dali::DaliException e) {
41093       {
41094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41095       };
41096     } catch (...) {
41097       {
41098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41099       };
41100     }
41101   }
41102
41103 }
41104
41105
41106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
41107   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41108   Dali::Radian arg2 ;
41109   Dali::Radian arg3 ;
41110   Dali::Radian *argp2 ;
41111   Dali::Radian *argp3 ;
41112
41113   arg1 = (Dali::PanGestureDetector *)jarg1;
41114   argp2 = (Dali::Radian *)jarg2;
41115   if (!argp2) {
41116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41117     return ;
41118   }
41119   arg2 = *argp2;
41120   argp3 = (Dali::Radian *)jarg3;
41121   if (!argp3) {
41122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41123     return ;
41124   }
41125   arg3 = *argp3;
41126   {
41127     try {
41128       (arg1)->AddDirection(arg2,arg3);
41129     } catch (std::out_of_range& e) {
41130       {
41131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41132       };
41133     } catch (std::exception& e) {
41134       {
41135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41136       };
41137     } catch (Dali::DaliException e) {
41138       {
41139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41140       };
41141     } catch (...) {
41142       {
41143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41144       };
41145     }
41146   }
41147
41148 }
41149
41150
41151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
41152   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41153   Dali::Radian arg2 ;
41154   Dali::Radian *argp2 ;
41155
41156   arg1 = (Dali::PanGestureDetector *)jarg1;
41157   argp2 = (Dali::Radian *)jarg2;
41158   if (!argp2) {
41159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41160     return ;
41161   }
41162   arg2 = *argp2;
41163   {
41164     try {
41165       (arg1)->AddDirection(arg2);
41166     } catch (std::out_of_range& e) {
41167       {
41168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41169       };
41170     } catch (std::exception& e) {
41171       {
41172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41173       };
41174     } catch (Dali::DaliException e) {
41175       {
41176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41177       };
41178     } catch (...) {
41179       {
41180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41181       };
41182     }
41183   }
41184
41185 }
41186
41187
41188 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41189   unsigned long jresult ;
41190   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41191   size_t result;
41192
41193   arg1 = (Dali::PanGestureDetector *)jarg1;
41194   {
41195     try {
41196       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41197     } catch (std::out_of_range& e) {
41198       {
41199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41200       };
41201     } catch (std::exception& e) {
41202       {
41203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41204       };
41205     } catch (Dali::DaliException e) {
41206       {
41207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41208       };
41209     } catch (...) {
41210       {
41211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41212       };
41213     }
41214   }
41215
41216   jresult = (unsigned long)result;
41217   return jresult;
41218 }
41219
41220
41221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41222   void * jresult ;
41223   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41224   size_t arg2 ;
41225   Dali::PanGestureDetector::AngleThresholdPair result;
41226
41227   arg1 = (Dali::PanGestureDetector *)jarg1;
41228   arg2 = (size_t)jarg2;
41229   {
41230     try {
41231       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41232     } catch (std::out_of_range& e) {
41233       {
41234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41235       };
41236     } catch (std::exception& e) {
41237       {
41238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41239       };
41240     } catch (Dali::DaliException e) {
41241       {
41242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41243       };
41244     } catch (...) {
41245       {
41246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41247       };
41248     }
41249   }
41250
41251   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41252   return jresult;
41253 }
41254
41255
41256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41257   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41258
41259   arg1 = (Dali::PanGestureDetector *)jarg1;
41260   {
41261     try {
41262       (arg1)->ClearAngles();
41263     } catch (std::out_of_range& e) {
41264       {
41265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41266       };
41267     } catch (std::exception& e) {
41268       {
41269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41270       };
41271     } catch (Dali::DaliException e) {
41272       {
41273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41274       };
41275     } catch (...) {
41276       {
41277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41278       };
41279     }
41280   }
41281
41282 }
41283
41284
41285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41286   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41287   Dali::Radian arg2 ;
41288   Dali::Radian *argp2 ;
41289
41290   arg1 = (Dali::PanGestureDetector *)jarg1;
41291   argp2 = (Dali::Radian *)jarg2;
41292   if (!argp2) {
41293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41294     return ;
41295   }
41296   arg2 = *argp2;
41297   {
41298     try {
41299       (arg1)->RemoveAngle(arg2);
41300     } catch (std::out_of_range& e) {
41301       {
41302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41303       };
41304     } catch (std::exception& e) {
41305       {
41306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41307       };
41308     } catch (Dali::DaliException e) {
41309       {
41310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41311       };
41312     } catch (...) {
41313       {
41314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41315       };
41316     }
41317   }
41318
41319 }
41320
41321
41322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41323   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41324   Dali::Radian arg2 ;
41325   Dali::Radian *argp2 ;
41326
41327   arg1 = (Dali::PanGestureDetector *)jarg1;
41328   argp2 = (Dali::Radian *)jarg2;
41329   if (!argp2) {
41330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41331     return ;
41332   }
41333   arg2 = *argp2;
41334   {
41335     try {
41336       (arg1)->RemoveDirection(arg2);
41337     } catch (std::out_of_range& e) {
41338       {
41339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41340       };
41341     } catch (std::exception& e) {
41342       {
41343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41344       };
41345     } catch (Dali::DaliException e) {
41346       {
41347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41348       };
41349     } catch (...) {
41350       {
41351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41352       };
41353     }
41354   }
41355
41356 }
41357
41358
41359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41360   void * jresult ;
41361   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41362   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41363
41364   arg1 = (Dali::PanGestureDetector *)jarg1;
41365   {
41366     try {
41367       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41368     } catch (std::out_of_range& e) {
41369       {
41370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41371       };
41372     } catch (std::exception& e) {
41373       {
41374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41375       };
41376     } catch (Dali::DaliException e) {
41377       {
41378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41379       };
41380     } catch (...) {
41381       {
41382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41383       };
41384     }
41385   }
41386
41387   jresult = (void *)result;
41388   return jresult;
41389 }
41390
41391
41392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41393   Dali::PanGesture *arg1 = 0 ;
41394
41395   arg1 = (Dali::PanGesture *)jarg1;
41396   if (!arg1) {
41397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41398     return ;
41399   }
41400   {
41401     try {
41402       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41403     } catch (std::out_of_range& e) {
41404       {
41405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41406       };
41407     } catch (std::exception& e) {
41408       {
41409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41410       };
41411     } catch (Dali::DaliException e) {
41412       {
41413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41414       };
41415     } catch (...) {
41416       {
41417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41418       };
41419     }
41420   }
41421
41422 }
41423
41424
41425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41426   void * jresult ;
41427   Dali::PanGesture *result = 0 ;
41428
41429   {
41430     try {
41431       result = (Dali::PanGesture *)new Dali::PanGesture();
41432     } catch (std::out_of_range& e) {
41433       {
41434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41435       };
41436     } catch (std::exception& e) {
41437       {
41438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41439       };
41440     } catch (Dali::DaliException e) {
41441       {
41442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41443       };
41444     } catch (...) {
41445       {
41446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41447       };
41448     }
41449   }
41450
41451   jresult = (void *)result;
41452   return jresult;
41453 }
41454
41455
41456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41457   void * jresult ;
41458   Dali::Gesture::State arg1 ;
41459   Dali::PanGesture *result = 0 ;
41460
41461   arg1 = (Dali::Gesture::State)jarg1;
41462   {
41463     try {
41464       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41465     } catch (std::out_of_range& e) {
41466       {
41467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41468       };
41469     } catch (std::exception& e) {
41470       {
41471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41472       };
41473     } catch (Dali::DaliException e) {
41474       {
41475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41476       };
41477     } catch (...) {
41478       {
41479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41480       };
41481     }
41482   }
41483
41484   jresult = (void *)result;
41485   return jresult;
41486 }
41487
41488
41489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41490   void * jresult ;
41491   Dali::PanGesture *arg1 = 0 ;
41492   Dali::PanGesture *result = 0 ;
41493
41494   arg1 = (Dali::PanGesture *)jarg1;
41495   if (!arg1) {
41496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41497     return 0;
41498   }
41499   {
41500     try {
41501       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41502     } catch (std::out_of_range& e) {
41503       {
41504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41505       };
41506     } catch (std::exception& e) {
41507       {
41508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41509       };
41510     } catch (Dali::DaliException e) {
41511       {
41512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41513       };
41514     } catch (...) {
41515       {
41516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41517       };
41518     }
41519   }
41520
41521   jresult = (void *)result;
41522   return jresult;
41523 }
41524
41525
41526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41527   void * jresult ;
41528   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41529   Dali::PanGesture *arg2 = 0 ;
41530   Dali::PanGesture *result = 0 ;
41531
41532   arg1 = (Dali::PanGesture *)jarg1;
41533   arg2 = (Dali::PanGesture *)jarg2;
41534   if (!arg2) {
41535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41536     return 0;
41537   }
41538   {
41539     try {
41540       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41541     } catch (std::out_of_range& e) {
41542       {
41543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41544       };
41545     } catch (std::exception& e) {
41546       {
41547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41548       };
41549     } catch (Dali::DaliException e) {
41550       {
41551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41552       };
41553     } catch (...) {
41554       {
41555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41556       };
41557     }
41558   }
41559
41560   jresult = (void *)result;
41561   return jresult;
41562 }
41563
41564
41565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41566   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41567
41568   arg1 = (Dali::PanGesture *)jarg1;
41569   {
41570     try {
41571       delete arg1;
41572     } catch (std::out_of_range& e) {
41573       {
41574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41575       };
41576     } catch (std::exception& e) {
41577       {
41578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41579       };
41580     } catch (Dali::DaliException e) {
41581       {
41582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41583       };
41584     } catch (...) {
41585       {
41586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41587       };
41588     }
41589   }
41590
41591 }
41592
41593
41594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41595   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41596   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41597
41598   arg1 = (Dali::PanGesture *)jarg1;
41599   arg2 = (Dali::Vector2 *)jarg2;
41600   if (arg1) (arg1)->velocity = *arg2;
41601 }
41602
41603
41604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41605   void * jresult ;
41606   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41607   Dali::Vector2 *result = 0 ;
41608
41609   arg1 = (Dali::PanGesture *)jarg1;
41610   result = (Dali::Vector2 *)& ((arg1)->velocity);
41611   jresult = (void *)result;
41612   return jresult;
41613 }
41614
41615
41616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41617   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41618   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41619
41620   arg1 = (Dali::PanGesture *)jarg1;
41621   arg2 = (Dali::Vector2 *)jarg2;
41622   if (arg1) (arg1)->displacement = *arg2;
41623 }
41624
41625
41626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41627   void * jresult ;
41628   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41629   Dali::Vector2 *result = 0 ;
41630
41631   arg1 = (Dali::PanGesture *)jarg1;
41632   result = (Dali::Vector2 *)& ((arg1)->displacement);
41633   jresult = (void *)result;
41634   return jresult;
41635 }
41636
41637
41638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41639   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41640   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41641
41642   arg1 = (Dali::PanGesture *)jarg1;
41643   arg2 = (Dali::Vector2 *)jarg2;
41644   if (arg1) (arg1)->position = *arg2;
41645 }
41646
41647
41648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41649   void * jresult ;
41650   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41651   Dali::Vector2 *result = 0 ;
41652
41653   arg1 = (Dali::PanGesture *)jarg1;
41654   result = (Dali::Vector2 *)& ((arg1)->position);
41655   jresult = (void *)result;
41656   return jresult;
41657 }
41658
41659
41660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41661   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41662   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41663
41664   arg1 = (Dali::PanGesture *)jarg1;
41665   arg2 = (Dali::Vector2 *)jarg2;
41666   if (arg1) (arg1)->screenVelocity = *arg2;
41667 }
41668
41669
41670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41671   void * jresult ;
41672   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41673   Dali::Vector2 *result = 0 ;
41674
41675   arg1 = (Dali::PanGesture *)jarg1;
41676   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41677   jresult = (void *)result;
41678   return jresult;
41679 }
41680
41681
41682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41683   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41684   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41685
41686   arg1 = (Dali::PanGesture *)jarg1;
41687   arg2 = (Dali::Vector2 *)jarg2;
41688   if (arg1) (arg1)->screenDisplacement = *arg2;
41689 }
41690
41691
41692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41693   void * jresult ;
41694   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41695   Dali::Vector2 *result = 0 ;
41696
41697   arg1 = (Dali::PanGesture *)jarg1;
41698   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41699   jresult = (void *)result;
41700   return jresult;
41701 }
41702
41703
41704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41705   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41706   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41707
41708   arg1 = (Dali::PanGesture *)jarg1;
41709   arg2 = (Dali::Vector2 *)jarg2;
41710   if (arg1) (arg1)->screenPosition = *arg2;
41711 }
41712
41713
41714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41715   void * jresult ;
41716   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41717   Dali::Vector2 *result = 0 ;
41718
41719   arg1 = (Dali::PanGesture *)jarg1;
41720   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41721   jresult = (void *)result;
41722   return jresult;
41723 }
41724
41725
41726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41727   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41728   unsigned int arg2 ;
41729
41730   arg1 = (Dali::PanGesture *)jarg1;
41731   arg2 = (unsigned int)jarg2;
41732   if (arg1) (arg1)->numberOfTouches = arg2;
41733 }
41734
41735
41736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41737   unsigned int jresult ;
41738   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41739   unsigned int result;
41740
41741   arg1 = (Dali::PanGesture *)jarg1;
41742   result = (unsigned int) ((arg1)->numberOfTouches);
41743   jresult = result;
41744   return jresult;
41745 }
41746
41747
41748 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41749   float jresult ;
41750   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41751   float result;
41752
41753   arg1 = (Dali::PanGesture *)jarg1;
41754   {
41755     try {
41756       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41757     } catch (std::out_of_range& e) {
41758       {
41759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41760       };
41761     } catch (std::exception& e) {
41762       {
41763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41764       };
41765     } catch (Dali::DaliException e) {
41766       {
41767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41768       };
41769     } catch (...) {
41770       {
41771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41772       };
41773     }
41774   }
41775
41776   jresult = result;
41777   return jresult;
41778 }
41779
41780
41781 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41782   float jresult ;
41783   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41784   float result;
41785
41786   arg1 = (Dali::PanGesture *)jarg1;
41787   {
41788     try {
41789       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41790     } catch (std::out_of_range& e) {
41791       {
41792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41793       };
41794     } catch (std::exception& e) {
41795       {
41796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41797       };
41798     } catch (Dali::DaliException e) {
41799       {
41800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41801       };
41802     } catch (...) {
41803       {
41804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41805       };
41806     }
41807   }
41808
41809   jresult = result;
41810   return jresult;
41811 }
41812
41813
41814 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41815   float jresult ;
41816   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41817   float result;
41818
41819   arg1 = (Dali::PanGesture *)jarg1;
41820   {
41821     try {
41822       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41823     } catch (std::out_of_range& e) {
41824       {
41825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41826       };
41827     } catch (std::exception& e) {
41828       {
41829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41830       };
41831     } catch (Dali::DaliException e) {
41832       {
41833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41834       };
41835     } catch (...) {
41836       {
41837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41838       };
41839     }
41840   }
41841
41842   jresult = result;
41843   return jresult;
41844 }
41845
41846
41847 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41848   float jresult ;
41849   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41850   float result;
41851
41852   arg1 = (Dali::PanGesture *)jarg1;
41853   {
41854     try {
41855       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41856     } catch (std::out_of_range& e) {
41857       {
41858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41859       };
41860     } catch (std::exception& e) {
41861       {
41862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41863       };
41864     } catch (Dali::DaliException e) {
41865       {
41866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41867       };
41868     } catch (...) {
41869       {
41870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41871       };
41872     }
41873   }
41874
41875   jresult = result;
41876   return jresult;
41877 }
41878
41879
41880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41881   void * jresult ;
41882   Dali::PinchGestureDetector *result = 0 ;
41883
41884   {
41885     try {
41886       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41887     } catch (std::out_of_range& e) {
41888       {
41889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41890       };
41891     } catch (std::exception& e) {
41892       {
41893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41894       };
41895     } catch (Dali::DaliException e) {
41896       {
41897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41898       };
41899     } catch (...) {
41900       {
41901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41902       };
41903     }
41904   }
41905
41906   jresult = (void *)result;
41907   return jresult;
41908 }
41909
41910
41911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41912   void * jresult ;
41913   Dali::PinchGestureDetector result;
41914
41915   {
41916     try {
41917       result = Dali::PinchGestureDetector::New();
41918     } catch (std::out_of_range& e) {
41919       {
41920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41921       };
41922     } catch (std::exception& e) {
41923       {
41924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41925       };
41926     } catch (Dali::DaliException e) {
41927       {
41928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41929       };
41930     } catch (...) {
41931       {
41932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41933       };
41934     }
41935   }
41936
41937   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41938   return jresult;
41939 }
41940
41941
41942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41943   void * jresult ;
41944   Dali::BaseHandle arg1 ;
41945   Dali::BaseHandle *argp1 ;
41946   Dali::PinchGestureDetector result;
41947
41948   argp1 = (Dali::BaseHandle *)jarg1;
41949   if (!argp1) {
41950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41951     return 0;
41952   }
41953   arg1 = *argp1;
41954   {
41955     try {
41956       result = Dali::PinchGestureDetector::DownCast(arg1);
41957     } catch (std::out_of_range& e) {
41958       {
41959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41960       };
41961     } catch (std::exception& e) {
41962       {
41963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41964       };
41965     } catch (Dali::DaliException e) {
41966       {
41967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41968       };
41969     } catch (...) {
41970       {
41971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41972       };
41973     }
41974   }
41975
41976   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41977   return jresult;
41978 }
41979
41980
41981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41982   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41983
41984   arg1 = (Dali::PinchGestureDetector *)jarg1;
41985   {
41986     try {
41987       delete arg1;
41988     } catch (std::out_of_range& e) {
41989       {
41990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41991       };
41992     } catch (std::exception& e) {
41993       {
41994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41995       };
41996     } catch (Dali::DaliException e) {
41997       {
41998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41999       };
42000     } catch (...) {
42001       {
42002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42003       };
42004     }
42005   }
42006
42007 }
42008
42009
42010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
42011   void * jresult ;
42012   Dali::PinchGestureDetector *arg1 = 0 ;
42013   Dali::PinchGestureDetector *result = 0 ;
42014
42015   arg1 = (Dali::PinchGestureDetector *)jarg1;
42016   if (!arg1) {
42017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
42018     return 0;
42019   }
42020   {
42021     try {
42022       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
42023     } catch (std::out_of_range& e) {
42024       {
42025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42026       };
42027     } catch (std::exception& e) {
42028       {
42029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42030       };
42031     } catch (Dali::DaliException e) {
42032       {
42033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42034       };
42035     } catch (...) {
42036       {
42037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42038       };
42039     }
42040   }
42041
42042   jresult = (void *)result;
42043   return jresult;
42044 }
42045
42046
42047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
42048   void * jresult ;
42049   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
42050   Dali::PinchGestureDetector *arg2 = 0 ;
42051   Dali::PinchGestureDetector *result = 0 ;
42052
42053   arg1 = (Dali::PinchGestureDetector *)jarg1;
42054   arg2 = (Dali::PinchGestureDetector *)jarg2;
42055   if (!arg2) {
42056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
42057     return 0;
42058   }
42059   {
42060     try {
42061       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
42062     } catch (std::out_of_range& e) {
42063       {
42064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42065       };
42066     } catch (std::exception& e) {
42067       {
42068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42069       };
42070     } catch (Dali::DaliException e) {
42071       {
42072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42073       };
42074     } catch (...) {
42075       {
42076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42077       };
42078     }
42079   }
42080
42081   jresult = (void *)result;
42082   return jresult;
42083 }
42084
42085
42086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
42087   void * jresult ;
42088   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
42089   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
42090
42091   arg1 = (Dali::PinchGestureDetector *)jarg1;
42092   {
42093     try {
42094       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42095     } catch (std::out_of_range& e) {
42096       {
42097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42098       };
42099     } catch (std::exception& e) {
42100       {
42101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42102       };
42103     } catch (Dali::DaliException e) {
42104       {
42105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42106       };
42107     } catch (...) {
42108       {
42109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42110       };
42111     }
42112   }
42113
42114   jresult = (void *)result;
42115   return jresult;
42116 }
42117
42118
42119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
42120   void * jresult ;
42121   Dali::Gesture::State arg1 ;
42122   Dali::PinchGesture *result = 0 ;
42123
42124   arg1 = (Dali::Gesture::State)jarg1;
42125   {
42126     try {
42127       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
42128     } catch (std::out_of_range& e) {
42129       {
42130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42131       };
42132     } catch (std::exception& e) {
42133       {
42134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42135       };
42136     } catch (Dali::DaliException e) {
42137       {
42138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42139       };
42140     } catch (...) {
42141       {
42142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42143       };
42144     }
42145   }
42146
42147   jresult = (void *)result;
42148   return jresult;
42149 }
42150
42151
42152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
42153   void * jresult ;
42154   Dali::PinchGesture *arg1 = 0 ;
42155   Dali::PinchGesture *result = 0 ;
42156
42157   arg1 = (Dali::PinchGesture *)jarg1;
42158   if (!arg1) {
42159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42160     return 0;
42161   }
42162   {
42163     try {
42164       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
42165     } catch (std::out_of_range& e) {
42166       {
42167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42168       };
42169     } catch (std::exception& e) {
42170       {
42171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42172       };
42173     } catch (Dali::DaliException e) {
42174       {
42175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42176       };
42177     } catch (...) {
42178       {
42179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42180       };
42181     }
42182   }
42183
42184   jresult = (void *)result;
42185   return jresult;
42186 }
42187
42188
42189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42190   void * jresult ;
42191   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42192   Dali::PinchGesture *arg2 = 0 ;
42193   Dali::PinchGesture *result = 0 ;
42194
42195   arg1 = (Dali::PinchGesture *)jarg1;
42196   arg2 = (Dali::PinchGesture *)jarg2;
42197   if (!arg2) {
42198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42199     return 0;
42200   }
42201   {
42202     try {
42203       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42204     } catch (std::out_of_range& e) {
42205       {
42206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42207       };
42208     } catch (std::exception& e) {
42209       {
42210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42211       };
42212     } catch (Dali::DaliException e) {
42213       {
42214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42215       };
42216     } catch (...) {
42217       {
42218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42219       };
42220     }
42221   }
42222
42223   jresult = (void *)result;
42224   return jresult;
42225 }
42226
42227
42228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42229   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42230
42231   arg1 = (Dali::PinchGesture *)jarg1;
42232   {
42233     try {
42234       delete arg1;
42235     } catch (std::out_of_range& e) {
42236       {
42237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42238       };
42239     } catch (std::exception& e) {
42240       {
42241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42242       };
42243     } catch (Dali::DaliException e) {
42244       {
42245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42246       };
42247     } catch (...) {
42248       {
42249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42250       };
42251     }
42252   }
42253
42254 }
42255
42256
42257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42258   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42259   float arg2 ;
42260
42261   arg1 = (Dali::PinchGesture *)jarg1;
42262   arg2 = (float)jarg2;
42263   if (arg1) (arg1)->scale = arg2;
42264 }
42265
42266
42267 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42268   float jresult ;
42269   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42270   float result;
42271
42272   arg1 = (Dali::PinchGesture *)jarg1;
42273   result = (float) ((arg1)->scale);
42274   jresult = result;
42275   return jresult;
42276 }
42277
42278
42279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42280   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42281   float arg2 ;
42282
42283   arg1 = (Dali::PinchGesture *)jarg1;
42284   arg2 = (float)jarg2;
42285   if (arg1) (arg1)->speed = arg2;
42286 }
42287
42288
42289 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42290   float jresult ;
42291   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42292   float result;
42293
42294   arg1 = (Dali::PinchGesture *)jarg1;
42295   result = (float) ((arg1)->speed);
42296   jresult = result;
42297   return jresult;
42298 }
42299
42300
42301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42302   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42303   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42304
42305   arg1 = (Dali::PinchGesture *)jarg1;
42306   arg2 = (Dali::Vector2 *)jarg2;
42307   if (arg1) (arg1)->screenCenterPoint = *arg2;
42308 }
42309
42310
42311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42312   void * jresult ;
42313   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42314   Dali::Vector2 *result = 0 ;
42315
42316   arg1 = (Dali::PinchGesture *)jarg1;
42317   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42318   jresult = (void *)result;
42319   return jresult;
42320 }
42321
42322
42323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42324   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42325   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42326
42327   arg1 = (Dali::PinchGesture *)jarg1;
42328   arg2 = (Dali::Vector2 *)jarg2;
42329   if (arg1) (arg1)->localCenterPoint = *arg2;
42330 }
42331
42332
42333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42334   void * jresult ;
42335   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42336   Dali::Vector2 *result = 0 ;
42337
42338   arg1 = (Dali::PinchGesture *)jarg1;
42339   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42340   jresult = (void *)result;
42341   return jresult;
42342 }
42343
42344
42345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42346   void * jresult ;
42347   Dali::TapGestureDetector *result = 0 ;
42348
42349   {
42350     try {
42351       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42352     } catch (std::out_of_range& e) {
42353       {
42354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42355       };
42356     } catch (std::exception& e) {
42357       {
42358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42359       };
42360     } catch (Dali::DaliException e) {
42361       {
42362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42363       };
42364     } catch (...) {
42365       {
42366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42367       };
42368     }
42369   }
42370
42371   jresult = (void *)result;
42372   return jresult;
42373 }
42374
42375
42376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42377   void * jresult ;
42378   Dali::TapGestureDetector result;
42379
42380   {
42381     try {
42382       result = Dali::TapGestureDetector::New();
42383     } catch (std::out_of_range& e) {
42384       {
42385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42386       };
42387     } catch (std::exception& e) {
42388       {
42389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42390       };
42391     } catch (Dali::DaliException e) {
42392       {
42393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42394       };
42395     } catch (...) {
42396       {
42397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42398       };
42399     }
42400   }
42401
42402   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42403   return jresult;
42404 }
42405
42406
42407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42408   void * jresult ;
42409   unsigned int arg1 ;
42410   Dali::TapGestureDetector result;
42411
42412   arg1 = (unsigned int)jarg1;
42413   {
42414     try {
42415       result = Dali::TapGestureDetector::New(arg1);
42416     } catch (std::out_of_range& e) {
42417       {
42418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42419       };
42420     } catch (std::exception& e) {
42421       {
42422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42423       };
42424     } catch (Dali::DaliException e) {
42425       {
42426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42427       };
42428     } catch (...) {
42429       {
42430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42431       };
42432     }
42433   }
42434
42435   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42436   return jresult;
42437 }
42438
42439
42440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42441   void * jresult ;
42442   Dali::BaseHandle arg1 ;
42443   Dali::BaseHandle *argp1 ;
42444   Dali::TapGestureDetector result;
42445
42446   argp1 = (Dali::BaseHandle *)jarg1;
42447   if (!argp1) {
42448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42449     return 0;
42450   }
42451   arg1 = *argp1;
42452   {
42453     try {
42454       result = Dali::TapGestureDetector::DownCast(arg1);
42455     } catch (std::out_of_range& e) {
42456       {
42457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42458       };
42459     } catch (std::exception& e) {
42460       {
42461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42462       };
42463     } catch (Dali::DaliException e) {
42464       {
42465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42466       };
42467     } catch (...) {
42468       {
42469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42470       };
42471     }
42472   }
42473
42474   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42475   return jresult;
42476 }
42477
42478
42479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42480   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42481
42482   arg1 = (Dali::TapGestureDetector *)jarg1;
42483   {
42484     try {
42485       delete arg1;
42486     } catch (std::out_of_range& e) {
42487       {
42488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42489       };
42490     } catch (std::exception& e) {
42491       {
42492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42493       };
42494     } catch (Dali::DaliException e) {
42495       {
42496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42497       };
42498     } catch (...) {
42499       {
42500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42501       };
42502     }
42503   }
42504
42505 }
42506
42507
42508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42509   void * jresult ;
42510   Dali::TapGestureDetector *arg1 = 0 ;
42511   Dali::TapGestureDetector *result = 0 ;
42512
42513   arg1 = (Dali::TapGestureDetector *)jarg1;
42514   if (!arg1) {
42515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42516     return 0;
42517   }
42518   {
42519     try {
42520       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42521     } catch (std::out_of_range& e) {
42522       {
42523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42524       };
42525     } catch (std::exception& e) {
42526       {
42527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42528       };
42529     } catch (Dali::DaliException e) {
42530       {
42531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42532       };
42533     } catch (...) {
42534       {
42535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42536       };
42537     }
42538   }
42539
42540   jresult = (void *)result;
42541   return jresult;
42542 }
42543
42544
42545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42546   void * jresult ;
42547   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42548   Dali::TapGestureDetector *arg2 = 0 ;
42549   Dali::TapGestureDetector *result = 0 ;
42550
42551   arg1 = (Dali::TapGestureDetector *)jarg1;
42552   arg2 = (Dali::TapGestureDetector *)jarg2;
42553   if (!arg2) {
42554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42555     return 0;
42556   }
42557   {
42558     try {
42559       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42560     } catch (std::out_of_range& e) {
42561       {
42562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42563       };
42564     } catch (std::exception& e) {
42565       {
42566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42567       };
42568     } catch (Dali::DaliException e) {
42569       {
42570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42571       };
42572     } catch (...) {
42573       {
42574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42575       };
42576     }
42577   }
42578
42579   jresult = (void *)result;
42580   return jresult;
42581 }
42582
42583
42584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42585   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42586   unsigned int arg2 ;
42587
42588   arg1 = (Dali::TapGestureDetector *)jarg1;
42589   arg2 = (unsigned int)jarg2;
42590   {
42591     try {
42592       (arg1)->SetMinimumTapsRequired(arg2);
42593     } catch (std::out_of_range& e) {
42594       {
42595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42596       };
42597     } catch (std::exception& e) {
42598       {
42599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42600       };
42601     } catch (Dali::DaliException e) {
42602       {
42603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42604       };
42605     } catch (...) {
42606       {
42607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42608       };
42609     }
42610   }
42611
42612 }
42613
42614
42615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42616   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42617   unsigned int arg2 ;
42618
42619   arg1 = (Dali::TapGestureDetector *)jarg1;
42620   arg2 = (unsigned int)jarg2;
42621   {
42622     try {
42623       (arg1)->SetMaximumTapsRequired(arg2);
42624     } catch (std::out_of_range& e) {
42625       {
42626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42627       };
42628     } catch (std::exception& e) {
42629       {
42630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42631       };
42632     } catch (Dali::DaliException e) {
42633       {
42634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42635       };
42636     } catch (...) {
42637       {
42638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42639       };
42640     }
42641   }
42642
42643 }
42644
42645
42646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42647   unsigned int jresult ;
42648   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42649   unsigned int result;
42650
42651   arg1 = (Dali::TapGestureDetector *)jarg1;
42652   {
42653     try {
42654       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42655     } catch (std::out_of_range& e) {
42656       {
42657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42658       };
42659     } catch (std::exception& e) {
42660       {
42661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42662       };
42663     } catch (Dali::DaliException e) {
42664       {
42665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42666       };
42667     } catch (...) {
42668       {
42669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42670       };
42671     }
42672   }
42673
42674   jresult = result;
42675   return jresult;
42676 }
42677
42678
42679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42680   unsigned int jresult ;
42681   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42682   unsigned int result;
42683
42684   arg1 = (Dali::TapGestureDetector *)jarg1;
42685   {
42686     try {
42687       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42688     } catch (std::out_of_range& e) {
42689       {
42690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42691       };
42692     } catch (std::exception& e) {
42693       {
42694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42695       };
42696     } catch (Dali::DaliException e) {
42697       {
42698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42699       };
42700     } catch (...) {
42701       {
42702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42703       };
42704     }
42705   }
42706
42707   jresult = result;
42708   return jresult;
42709 }
42710
42711
42712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42713   void * jresult ;
42714   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42715   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42716
42717   arg1 = (Dali::TapGestureDetector *)jarg1;
42718   {
42719     try {
42720       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42721     } catch (std::out_of_range& e) {
42722       {
42723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42724       };
42725     } catch (std::exception& e) {
42726       {
42727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42728       };
42729     } catch (Dali::DaliException e) {
42730       {
42731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42732       };
42733     } catch (...) {
42734       {
42735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42736       };
42737     }
42738   }
42739
42740   jresult = (void *)result;
42741   return jresult;
42742 }
42743
42744
42745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42746   void * jresult ;
42747   Dali::TapGesture *result = 0 ;
42748
42749   {
42750     try {
42751       result = (Dali::TapGesture *)new Dali::TapGesture();
42752     } catch (std::out_of_range& e) {
42753       {
42754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42755       };
42756     } catch (std::exception& e) {
42757       {
42758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42759       };
42760     } catch (Dali::DaliException e) {
42761       {
42762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42763       };
42764     } catch (...) {
42765       {
42766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42767       };
42768     }
42769   }
42770
42771   jresult = (void *)result;
42772   return jresult;
42773 }
42774
42775
42776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42777   void * jresult ;
42778   Dali::TapGesture *arg1 = 0 ;
42779   Dali::TapGesture *result = 0 ;
42780
42781   arg1 = (Dali::TapGesture *)jarg1;
42782   if (!arg1) {
42783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42784     return 0;
42785   }
42786   {
42787     try {
42788       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42789     } catch (std::out_of_range& e) {
42790       {
42791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42792       };
42793     } catch (std::exception& e) {
42794       {
42795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42796       };
42797     } catch (Dali::DaliException e) {
42798       {
42799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42800       };
42801     } catch (...) {
42802       {
42803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42804       };
42805     }
42806   }
42807
42808   jresult = (void *)result;
42809   return jresult;
42810 }
42811
42812
42813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42814   void * jresult ;
42815   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42816   Dali::TapGesture *arg2 = 0 ;
42817   Dali::TapGesture *result = 0 ;
42818
42819   arg1 = (Dali::TapGesture *)jarg1;
42820   arg2 = (Dali::TapGesture *)jarg2;
42821   if (!arg2) {
42822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42823     return 0;
42824   }
42825   {
42826     try {
42827       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42828     } catch (std::out_of_range& e) {
42829       {
42830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42831       };
42832     } catch (std::exception& e) {
42833       {
42834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42835       };
42836     } catch (Dali::DaliException e) {
42837       {
42838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42839       };
42840     } catch (...) {
42841       {
42842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42843       };
42844     }
42845   }
42846
42847   jresult = (void *)result;
42848   return jresult;
42849 }
42850
42851
42852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42853   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42854
42855   arg1 = (Dali::TapGesture *)jarg1;
42856   {
42857     try {
42858       delete arg1;
42859     } catch (std::out_of_range& e) {
42860       {
42861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42862       };
42863     } catch (std::exception& e) {
42864       {
42865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42866       };
42867     } catch (Dali::DaliException e) {
42868       {
42869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42870       };
42871     } catch (...) {
42872       {
42873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42874       };
42875     }
42876   }
42877
42878 }
42879
42880
42881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42882   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42883   unsigned int arg2 ;
42884
42885   arg1 = (Dali::TapGesture *)jarg1;
42886   arg2 = (unsigned int)jarg2;
42887   if (arg1) (arg1)->numberOfTaps = arg2;
42888 }
42889
42890
42891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42892   unsigned int jresult ;
42893   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42894   unsigned int result;
42895
42896   arg1 = (Dali::TapGesture *)jarg1;
42897   result = (unsigned int) ((arg1)->numberOfTaps);
42898   jresult = result;
42899   return jresult;
42900 }
42901
42902
42903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42904   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42905   unsigned int arg2 ;
42906
42907   arg1 = (Dali::TapGesture *)jarg1;
42908   arg2 = (unsigned int)jarg2;
42909   if (arg1) (arg1)->numberOfTouches = arg2;
42910 }
42911
42912
42913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42914   unsigned int jresult ;
42915   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42916   unsigned int result;
42917
42918   arg1 = (Dali::TapGesture *)jarg1;
42919   result = (unsigned int) ((arg1)->numberOfTouches);
42920   jresult = result;
42921   return jresult;
42922 }
42923
42924
42925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42926   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42927   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42928
42929   arg1 = (Dali::TapGesture *)jarg1;
42930   arg2 = (Dali::Vector2 *)jarg2;
42931   if (arg1) (arg1)->screenPoint = *arg2;
42932 }
42933
42934
42935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42936   void * jresult ;
42937   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42938   Dali::Vector2 *result = 0 ;
42939
42940   arg1 = (Dali::TapGesture *)jarg1;
42941   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42942   jresult = (void *)result;
42943   return jresult;
42944 }
42945
42946
42947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42948   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42949   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42950
42951   arg1 = (Dali::TapGesture *)jarg1;
42952   arg2 = (Dali::Vector2 *)jarg2;
42953   if (arg1) (arg1)->localPoint = *arg2;
42954 }
42955
42956
42957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42958   void * jresult ;
42959   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42960   Dali::Vector2 *result = 0 ;
42961
42962   arg1 = (Dali::TapGesture *)jarg1;
42963   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42964   jresult = (void *)result;
42965   return jresult;
42966 }
42967
42968
42969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42970   void * jresult ;
42971   Dali::AlphaFunction *result = 0 ;
42972
42973   {
42974     try {
42975       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42976     } catch (std::out_of_range& e) {
42977       {
42978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42979       };
42980     } catch (std::exception& e) {
42981       {
42982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42983       };
42984     } catch (Dali::DaliException e) {
42985       {
42986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42987       };
42988     } catch (...) {
42989       {
42990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42991       };
42992     }
42993   }
42994
42995   jresult = (void *)result;
42996   return jresult;
42997 }
42998
42999
43000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
43001   void * jresult ;
43002   Dali::AlphaFunction::BuiltinFunction arg1 ;
43003   Dali::AlphaFunction *result = 0 ;
43004
43005   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
43006   {
43007     try {
43008       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
43009     } catch (std::out_of_range& e) {
43010       {
43011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43012       };
43013     } catch (std::exception& e) {
43014       {
43015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43016       };
43017     } catch (Dali::DaliException e) {
43018       {
43019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43020       };
43021     } catch (...) {
43022       {
43023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43024       };
43025     }
43026   }
43027
43028   jresult = (void *)result;
43029   return jresult;
43030 }
43031
43032
43033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
43034   void * jresult ;
43035   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
43036   Dali::AlphaFunction *result = 0 ;
43037
43038   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
43039   {
43040     try {
43041       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
43042     } catch (std::out_of_range& e) {
43043       {
43044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43045       };
43046     } catch (std::exception& e) {
43047       {
43048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43049       };
43050     } catch (Dali::DaliException e) {
43051       {
43052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43053       };
43054     } catch (...) {
43055       {
43056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43057       };
43058     }
43059   }
43060
43061   jresult = (void *)result;
43062   return jresult;
43063 }
43064
43065
43066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
43067   void * jresult ;
43068   Dali::Vector2 *arg1 = 0 ;
43069   Dali::Vector2 *arg2 = 0 ;
43070   Dali::AlphaFunction *result = 0 ;
43071
43072   arg1 = (Dali::Vector2 *)jarg1;
43073   if (!arg1) {
43074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43075     return 0;
43076   }
43077   arg2 = (Dali::Vector2 *)jarg2;
43078   if (!arg2) {
43079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43080     return 0;
43081   }
43082   {
43083     try {
43084       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
43085     } catch (std::out_of_range& e) {
43086       {
43087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43088       };
43089     } catch (std::exception& e) {
43090       {
43091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43092       };
43093     } catch (Dali::DaliException e) {
43094       {
43095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43096       };
43097     } catch (...) {
43098       {
43099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43100       };
43101     }
43102   }
43103
43104   jresult = (void *)result;
43105   return jresult;
43106 }
43107
43108
43109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
43110   void * jresult ;
43111   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43112   Dali::Vector4 result;
43113
43114   arg1 = (Dali::AlphaFunction *)jarg1;
43115   {
43116     try {
43117       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
43118     } catch (std::out_of_range& e) {
43119       {
43120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43121       };
43122     } catch (std::exception& e) {
43123       {
43124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43125       };
43126     } catch (Dali::DaliException e) {
43127       {
43128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43129       };
43130     } catch (...) {
43131       {
43132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43133       };
43134     }
43135   }
43136
43137   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43138   return jresult;
43139 }
43140
43141
43142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
43143   void * jresult ;
43144   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43145   Dali::AlphaFunctionPrototype result;
43146
43147   arg1 = (Dali::AlphaFunction *)jarg1;
43148   {
43149     try {
43150       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
43151     } catch (std::out_of_range& e) {
43152       {
43153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43154       };
43155     } catch (std::exception& e) {
43156       {
43157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43158       };
43159     } catch (Dali::DaliException e) {
43160       {
43161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43162       };
43163     } catch (...) {
43164       {
43165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43166       };
43167     }
43168   }
43169
43170   jresult = (void *)result;
43171   return jresult;
43172 }
43173
43174
43175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43176   int jresult ;
43177   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43178   Dali::AlphaFunction::BuiltinFunction result;
43179
43180   arg1 = (Dali::AlphaFunction *)jarg1;
43181   {
43182     try {
43183       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43184     } catch (std::out_of_range& e) {
43185       {
43186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43187       };
43188     } catch (std::exception& e) {
43189       {
43190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43191       };
43192     } catch (Dali::DaliException e) {
43193       {
43194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43195       };
43196     } catch (...) {
43197       {
43198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43199       };
43200     }
43201   }
43202
43203   jresult = (int)result;
43204   return jresult;
43205 }
43206
43207
43208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43209   int jresult ;
43210   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43211   Dali::AlphaFunction::Mode result;
43212
43213   arg1 = (Dali::AlphaFunction *)jarg1;
43214   {
43215     try {
43216       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43217     } catch (std::out_of_range& e) {
43218       {
43219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43220       };
43221     } catch (std::exception& e) {
43222       {
43223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43224       };
43225     } catch (Dali::DaliException e) {
43226       {
43227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43228       };
43229     } catch (...) {
43230       {
43231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43232       };
43233     }
43234   }
43235
43236   jresult = (int)result;
43237   return jresult;
43238 }
43239
43240
43241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43242   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43243
43244   arg1 = (Dali::AlphaFunction *)jarg1;
43245   {
43246     try {
43247       delete arg1;
43248     } catch (std::out_of_range& e) {
43249       {
43250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43251       };
43252     } catch (std::exception& e) {
43253       {
43254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43255       };
43256     } catch (Dali::DaliException e) {
43257       {
43258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43259       };
43260     } catch (...) {
43261       {
43262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43263       };
43264     }
43265   }
43266
43267 }
43268
43269
43270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43271   void * jresult ;
43272   Dali::KeyFrames result;
43273
43274   {
43275     try {
43276       result = Dali::KeyFrames::New();
43277     } catch (std::out_of_range& e) {
43278       {
43279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43280       };
43281     } catch (std::exception& e) {
43282       {
43283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43284       };
43285     } catch (Dali::DaliException e) {
43286       {
43287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43288       };
43289     } catch (...) {
43290       {
43291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43292       };
43293     }
43294   }
43295
43296   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43297   return jresult;
43298 }
43299
43300
43301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43302   void * jresult ;
43303   Dali::BaseHandle arg1 ;
43304   Dali::BaseHandle *argp1 ;
43305   Dali::KeyFrames result;
43306
43307   argp1 = (Dali::BaseHandle *)jarg1;
43308   if (!argp1) {
43309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43310     return 0;
43311   }
43312   arg1 = *argp1;
43313   {
43314     try {
43315       result = Dali::KeyFrames::DownCast(arg1);
43316     } catch (std::out_of_range& e) {
43317       {
43318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43319       };
43320     } catch (std::exception& e) {
43321       {
43322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43323       };
43324     } catch (Dali::DaliException e) {
43325       {
43326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43327       };
43328     } catch (...) {
43329       {
43330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43331       };
43332     }
43333   }
43334
43335   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43336   return jresult;
43337 }
43338
43339
43340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43341   void * jresult ;
43342   Dali::KeyFrames *result = 0 ;
43343
43344   {
43345     try {
43346       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43347     } catch (std::out_of_range& e) {
43348       {
43349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43350       };
43351     } catch (std::exception& e) {
43352       {
43353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43354       };
43355     } catch (Dali::DaliException e) {
43356       {
43357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43358       };
43359     } catch (...) {
43360       {
43361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43362       };
43363     }
43364   }
43365
43366   jresult = (void *)result;
43367   return jresult;
43368 }
43369
43370
43371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43372   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43373
43374   arg1 = (Dali::KeyFrames *)jarg1;
43375   {
43376     try {
43377       delete arg1;
43378     } catch (std::out_of_range& e) {
43379       {
43380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43381       };
43382     } catch (std::exception& e) {
43383       {
43384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43385       };
43386     } catch (Dali::DaliException e) {
43387       {
43388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43389       };
43390     } catch (...) {
43391       {
43392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43393       };
43394     }
43395   }
43396
43397 }
43398
43399
43400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43401   void * jresult ;
43402   Dali::KeyFrames *arg1 = 0 ;
43403   Dali::KeyFrames *result = 0 ;
43404
43405   arg1 = (Dali::KeyFrames *)jarg1;
43406   if (!arg1) {
43407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43408     return 0;
43409   }
43410   {
43411     try {
43412       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43413     } catch (std::out_of_range& e) {
43414       {
43415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43416       };
43417     } catch (std::exception& e) {
43418       {
43419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43420       };
43421     } catch (Dali::DaliException e) {
43422       {
43423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43424       };
43425     } catch (...) {
43426       {
43427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43428       };
43429     }
43430   }
43431
43432   jresult = (void *)result;
43433   return jresult;
43434 }
43435
43436
43437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43438   void * jresult ;
43439   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43440   Dali::KeyFrames *arg2 = 0 ;
43441   Dali::KeyFrames *result = 0 ;
43442
43443   arg1 = (Dali::KeyFrames *)jarg1;
43444   arg2 = (Dali::KeyFrames *)jarg2;
43445   if (!arg2) {
43446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43447     return 0;
43448   }
43449   {
43450     try {
43451       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43452     } catch (std::out_of_range& e) {
43453       {
43454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43455       };
43456     } catch (std::exception& e) {
43457       {
43458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43459       };
43460     } catch (Dali::DaliException e) {
43461       {
43462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43463       };
43464     } catch (...) {
43465       {
43466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43467       };
43468     }
43469   }
43470
43471   jresult = (void *)result;
43472   return jresult;
43473 }
43474
43475
43476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43477   int jresult ;
43478   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43479   Dali::Property::Type result;
43480
43481   arg1 = (Dali::KeyFrames *)jarg1;
43482   {
43483     try {
43484       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43485     } catch (std::out_of_range& e) {
43486       {
43487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43488       };
43489     } catch (std::exception& e) {
43490       {
43491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43492       };
43493     } catch (Dali::DaliException e) {
43494       {
43495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43496       };
43497     } catch (...) {
43498       {
43499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43500       };
43501     }
43502   }
43503
43504   jresult = (int)result;
43505   return jresult;
43506 }
43507
43508
43509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43510   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43511   float arg2 ;
43512   Dali::Property::Value arg3 ;
43513   Dali::Property::Value *argp3 ;
43514
43515   arg1 = (Dali::KeyFrames *)jarg1;
43516   arg2 = (float)jarg2;
43517   argp3 = (Dali::Property::Value *)jarg3;
43518   if (!argp3) {
43519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43520     return ;
43521   }
43522   arg3 = *argp3;
43523   {
43524     try {
43525       (arg1)->Add(arg2,arg3);
43526     } catch (std::out_of_range& e) {
43527       {
43528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43529       };
43530     } catch (std::exception& e) {
43531       {
43532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43533       };
43534     } catch (Dali::DaliException e) {
43535       {
43536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43537       };
43538     } catch (...) {
43539       {
43540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43541       };
43542     }
43543   }
43544
43545 }
43546
43547
43548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43549   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43550   float arg2 ;
43551   Dali::Property::Value arg3 ;
43552   Dali::AlphaFunction arg4 ;
43553   Dali::Property::Value *argp3 ;
43554   Dali::AlphaFunction *argp4 ;
43555
43556   arg1 = (Dali::KeyFrames *)jarg1;
43557   arg2 = (float)jarg2;
43558   argp3 = (Dali::Property::Value *)jarg3;
43559   if (!argp3) {
43560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43561     return ;
43562   }
43563   arg3 = *argp3;
43564   argp4 = (Dali::AlphaFunction *)jarg4;
43565   if (!argp4) {
43566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43567     return ;
43568   }
43569   arg4 = *argp4;
43570   {
43571     try {
43572       (arg1)->Add(arg2,arg3,arg4);
43573     } catch (std::out_of_range& e) {
43574       {
43575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43576       };
43577     } catch (std::exception& e) {
43578       {
43579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43580       };
43581     } catch (Dali::DaliException e) {
43582       {
43583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43584       };
43585     } catch (...) {
43586       {
43587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43588       };
43589     }
43590   }
43591
43592 }
43593
43594
43595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43596   int jresult ;
43597   int result;
43598
43599   result = (int)Dali::Path::Property::POINTS;
43600   jresult = (int)result;
43601   return jresult;
43602 }
43603
43604
43605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43606   int jresult ;
43607   int result;
43608
43609   result = (int)Dali::Path::Property::CONTROL_POINTS;
43610   jresult = (int)result;
43611   return jresult;
43612 }
43613
43614
43615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43616   void * jresult ;
43617   Dali::Path::Property *result = 0 ;
43618
43619   {
43620     try {
43621       result = (Dali::Path::Property *)new Dali::Path::Property();
43622     } catch (std::out_of_range& e) {
43623       {
43624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43625       };
43626     } catch (std::exception& e) {
43627       {
43628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43629       };
43630     } catch (Dali::DaliException e) {
43631       {
43632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43633       };
43634     } catch (...) {
43635       {
43636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43637       };
43638     }
43639   }
43640
43641   jresult = (void *)result;
43642   return jresult;
43643 }
43644
43645
43646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43647   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43648
43649   arg1 = (Dali::Path::Property *)jarg1;
43650   {
43651     try {
43652       delete arg1;
43653     } catch (std::out_of_range& e) {
43654       {
43655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43656       };
43657     } catch (std::exception& e) {
43658       {
43659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43660       };
43661     } catch (Dali::DaliException e) {
43662       {
43663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43664       };
43665     } catch (...) {
43666       {
43667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43668       };
43669     }
43670   }
43671
43672 }
43673
43674
43675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43676   void * jresult ;
43677   Dali::Path result;
43678
43679   {
43680     try {
43681       result = Dali::Path::New();
43682     } catch (std::out_of_range& e) {
43683       {
43684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43685       };
43686     } catch (std::exception& e) {
43687       {
43688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43689       };
43690     } catch (Dali::DaliException e) {
43691       {
43692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43693       };
43694     } catch (...) {
43695       {
43696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43697       };
43698     }
43699   }
43700
43701   jresult = new Dali::Path((const Dali::Path &)result);
43702   return jresult;
43703 }
43704
43705
43706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43707   void * jresult ;
43708   Dali::BaseHandle arg1 ;
43709   Dali::BaseHandle *argp1 ;
43710   Dali::Path result;
43711
43712   argp1 = (Dali::BaseHandle *)jarg1;
43713   if (!argp1) {
43714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43715     return 0;
43716   }
43717   arg1 = *argp1;
43718   {
43719     try {
43720       result = Dali::Path::DownCast(arg1);
43721     } catch (std::out_of_range& e) {
43722       {
43723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43724       };
43725     } catch (std::exception& e) {
43726       {
43727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43728       };
43729     } catch (Dali::DaliException e) {
43730       {
43731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43732       };
43733     } catch (...) {
43734       {
43735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43736       };
43737     }
43738   }
43739
43740   jresult = new Dali::Path((const Dali::Path &)result);
43741   return jresult;
43742 }
43743
43744
43745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43746   void * jresult ;
43747   Dali::Path *result = 0 ;
43748
43749   {
43750     try {
43751       result = (Dali::Path *)new Dali::Path();
43752     } catch (std::out_of_range& e) {
43753       {
43754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43755       };
43756     } catch (std::exception& e) {
43757       {
43758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43759       };
43760     } catch (Dali::DaliException e) {
43761       {
43762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43763       };
43764     } catch (...) {
43765       {
43766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43767       };
43768     }
43769   }
43770
43771   jresult = (void *)result;
43772   return jresult;
43773 }
43774
43775
43776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43777   Dali::Path *arg1 = (Dali::Path *) 0 ;
43778
43779   arg1 = (Dali::Path *)jarg1;
43780   {
43781     try {
43782       delete arg1;
43783     } catch (std::out_of_range& e) {
43784       {
43785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43786       };
43787     } catch (std::exception& e) {
43788       {
43789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43790       };
43791     } catch (Dali::DaliException e) {
43792       {
43793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43794       };
43795     } catch (...) {
43796       {
43797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43798       };
43799     }
43800   }
43801
43802 }
43803
43804
43805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43806   void * jresult ;
43807   Dali::Path *arg1 = 0 ;
43808   Dali::Path *result = 0 ;
43809
43810   arg1 = (Dali::Path *)jarg1;
43811   if (!arg1) {
43812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43813     return 0;
43814   }
43815   {
43816     try {
43817       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43818     } catch (std::out_of_range& e) {
43819       {
43820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43821       };
43822     } catch (std::exception& e) {
43823       {
43824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43825       };
43826     } catch (Dali::DaliException e) {
43827       {
43828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43829       };
43830     } catch (...) {
43831       {
43832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43833       };
43834     }
43835   }
43836
43837   jresult = (void *)result;
43838   return jresult;
43839 }
43840
43841
43842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43843   void * jresult ;
43844   Dali::Path *arg1 = (Dali::Path *) 0 ;
43845   Dali::Path *arg2 = 0 ;
43846   Dali::Path *result = 0 ;
43847
43848   arg1 = (Dali::Path *)jarg1;
43849   arg2 = (Dali::Path *)jarg2;
43850   if (!arg2) {
43851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43852     return 0;
43853   }
43854   {
43855     try {
43856       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43857     } catch (std::out_of_range& e) {
43858       {
43859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43860       };
43861     } catch (std::exception& e) {
43862       {
43863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43864       };
43865     } catch (Dali::DaliException e) {
43866       {
43867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43868       };
43869     } catch (...) {
43870       {
43871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43872       };
43873     }
43874   }
43875
43876   jresult = (void *)result;
43877   return jresult;
43878 }
43879
43880
43881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43882   Dali::Path *arg1 = (Dali::Path *) 0 ;
43883   Dali::Vector3 *arg2 = 0 ;
43884
43885   arg1 = (Dali::Path *)jarg1;
43886   arg2 = (Dali::Vector3 *)jarg2;
43887   if (!arg2) {
43888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43889     return ;
43890   }
43891   {
43892     try {
43893       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43894     } catch (std::out_of_range& e) {
43895       {
43896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43897       };
43898     } catch (std::exception& e) {
43899       {
43900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43901       };
43902     } catch (Dali::DaliException e) {
43903       {
43904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43905       };
43906     } catch (...) {
43907       {
43908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43909       };
43910     }
43911   }
43912
43913 }
43914
43915
43916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43917   Dali::Path *arg1 = (Dali::Path *) 0 ;
43918   Dali::Vector3 *arg2 = 0 ;
43919
43920   arg1 = (Dali::Path *)jarg1;
43921   arg2 = (Dali::Vector3 *)jarg2;
43922   if (!arg2) {
43923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43924     return ;
43925   }
43926   {
43927     try {
43928       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43929     } catch (std::out_of_range& e) {
43930       {
43931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43932       };
43933     } catch (std::exception& e) {
43934       {
43935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43936       };
43937     } catch (Dali::DaliException e) {
43938       {
43939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43940       };
43941     } catch (...) {
43942       {
43943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43944       };
43945     }
43946   }
43947
43948 }
43949
43950
43951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43952   Dali::Path *arg1 = (Dali::Path *) 0 ;
43953   float arg2 ;
43954
43955   arg1 = (Dali::Path *)jarg1;
43956   arg2 = (float)jarg2;
43957   {
43958     try {
43959       (arg1)->GenerateControlPoints(arg2);
43960     } catch (std::out_of_range& e) {
43961       {
43962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43963       };
43964     } catch (std::exception& e) {
43965       {
43966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43967       };
43968     } catch (Dali::DaliException e) {
43969       {
43970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43971       };
43972     } catch (...) {
43973       {
43974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43975       };
43976     }
43977   }
43978
43979 }
43980
43981
43982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43983   Dali::Path *arg1 = (Dali::Path *) 0 ;
43984   float arg2 ;
43985   Dali::Vector3 *arg3 = 0 ;
43986   Dali::Vector3 *arg4 = 0 ;
43987
43988   arg1 = (Dali::Path *)jarg1;
43989   arg2 = (float)jarg2;
43990   arg3 = (Dali::Vector3 *)jarg3;
43991   if (!arg3) {
43992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43993     return ;
43994   }
43995   arg4 = (Dali::Vector3 *)jarg4;
43996   if (!arg4) {
43997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43998     return ;
43999   }
44000   {
44001     try {
44002       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
44003     } catch (std::out_of_range& e) {
44004       {
44005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44006       };
44007     } catch (std::exception& e) {
44008       {
44009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44010       };
44011     } catch (Dali::DaliException e) {
44012       {
44013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44014       };
44015     } catch (...) {
44016       {
44017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44018       };
44019     }
44020   }
44021
44022 }
44023
44024
44025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
44026   void * jresult ;
44027   Dali::Path *arg1 = (Dali::Path *) 0 ;
44028   size_t arg2 ;
44029   Dali::Vector3 *result = 0 ;
44030
44031   arg1 = (Dali::Path *)jarg1;
44032   arg2 = (size_t)jarg2;
44033   {
44034     try {
44035       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
44036     } catch (std::out_of_range& e) {
44037       {
44038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44039       };
44040     } catch (std::exception& e) {
44041       {
44042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44043       };
44044     } catch (Dali::DaliException e) {
44045       {
44046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44047       };
44048     } catch (...) {
44049       {
44050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44051       };
44052     }
44053   }
44054
44055   jresult = (void *)result;
44056   return jresult;
44057 }
44058
44059
44060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
44061   void * jresult ;
44062   Dali::Path *arg1 = (Dali::Path *) 0 ;
44063   size_t arg2 ;
44064   Dali::Vector3 *result = 0 ;
44065
44066   arg1 = (Dali::Path *)jarg1;
44067   arg2 = (size_t)jarg2;
44068   {
44069     try {
44070       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
44071     } catch (std::out_of_range& e) {
44072       {
44073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44074       };
44075     } catch (std::exception& e) {
44076       {
44077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44078       };
44079     } catch (Dali::DaliException e) {
44080       {
44081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44082       };
44083     } catch (...) {
44084       {
44085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44086       };
44087     }
44088   }
44089
44090   jresult = (void *)result;
44091   return jresult;
44092 }
44093
44094
44095 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
44096   unsigned long jresult ;
44097   Dali::Path *arg1 = (Dali::Path *) 0 ;
44098   size_t result;
44099
44100   arg1 = (Dali::Path *)jarg1;
44101   {
44102     try {
44103       result = ((Dali::Path const *)arg1)->GetPointCount();
44104     } catch (std::out_of_range& e) {
44105       {
44106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44107       };
44108     } catch (std::exception& e) {
44109       {
44110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44111       };
44112     } catch (Dali::DaliException e) {
44113       {
44114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44115       };
44116     } catch (...) {
44117       {
44118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44119       };
44120     }
44121   }
44122
44123   jresult = (unsigned long)result;
44124   return jresult;
44125 }
44126
44127
44128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
44129   void * jresult ;
44130   float arg1 ;
44131   Dali::TimePeriod *result = 0 ;
44132
44133   arg1 = (float)jarg1;
44134   {
44135     try {
44136       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
44137     } catch (std::out_of_range& e) {
44138       {
44139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44140       };
44141     } catch (std::exception& e) {
44142       {
44143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44144       };
44145     } catch (Dali::DaliException e) {
44146       {
44147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44148       };
44149     } catch (...) {
44150       {
44151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44152       };
44153     }
44154   }
44155
44156   jresult = (void *)result;
44157   return jresult;
44158 }
44159
44160
44161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
44162   void * jresult ;
44163   float arg1 ;
44164   float arg2 ;
44165   Dali::TimePeriod *result = 0 ;
44166
44167   arg1 = (float)jarg1;
44168   arg2 = (float)jarg2;
44169   {
44170     try {
44171       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44172     } catch (std::out_of_range& e) {
44173       {
44174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44175       };
44176     } catch (std::exception& e) {
44177       {
44178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44179       };
44180     } catch (Dali::DaliException e) {
44181       {
44182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44183       };
44184     } catch (...) {
44185       {
44186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44187       };
44188     }
44189   }
44190
44191   jresult = (void *)result;
44192   return jresult;
44193 }
44194
44195
44196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44197   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44198
44199   arg1 = (Dali::TimePeriod *)jarg1;
44200   {
44201     try {
44202       delete arg1;
44203     } catch (std::out_of_range& e) {
44204       {
44205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44206       };
44207     } catch (std::exception& e) {
44208       {
44209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44210       };
44211     } catch (Dali::DaliException e) {
44212       {
44213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44214       };
44215     } catch (...) {
44216       {
44217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44218       };
44219     }
44220   }
44221
44222 }
44223
44224
44225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44226   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44227   float arg2 ;
44228
44229   arg1 = (Dali::TimePeriod *)jarg1;
44230   arg2 = (float)jarg2;
44231   if (arg1) (arg1)->delaySeconds = arg2;
44232 }
44233
44234
44235 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44236   float jresult ;
44237   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44238   float result;
44239
44240   arg1 = (Dali::TimePeriod *)jarg1;
44241   result = (float) ((arg1)->delaySeconds);
44242   jresult = result;
44243   return jresult;
44244 }
44245
44246
44247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44248   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44249   float arg2 ;
44250
44251   arg1 = (Dali::TimePeriod *)jarg1;
44252   arg2 = (float)jarg2;
44253   if (arg1) (arg1)->durationSeconds = arg2;
44254 }
44255
44256
44257 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44258   float jresult ;
44259   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44260   float result;
44261
44262   arg1 = (Dali::TimePeriod *)jarg1;
44263   result = (float) ((arg1)->durationSeconds);
44264   jresult = result;
44265   return jresult;
44266 }
44267
44268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44269   int jresult ;
44270   int result;
44271
44272   result = (int)Dali::LinearConstrainer::Property::VALUE;
44273   jresult = (int)result;
44274   return jresult;
44275 }
44276
44277
44278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44279   int jresult ;
44280   int result;
44281
44282   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44283   jresult = (int)result;
44284   return jresult;
44285 }
44286
44287
44288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44289   void * jresult ;
44290   Dali::LinearConstrainer::Property *result = 0 ;
44291
44292   {
44293     try {
44294       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44295     } catch (std::out_of_range& e) {
44296       {
44297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44298       };
44299     } catch (std::exception& e) {
44300       {
44301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44302       };
44303     } catch (Dali::DaliException e) {
44304       {
44305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44306       };
44307     } catch (...) {
44308       {
44309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44310       };
44311     }
44312   }
44313
44314   jresult = (void *)result;
44315   return jresult;
44316 }
44317
44318
44319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44320   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44321
44322   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44323   {
44324     try {
44325       delete arg1;
44326     } catch (std::out_of_range& e) {
44327       {
44328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44329       };
44330     } catch (std::exception& e) {
44331       {
44332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44333       };
44334     } catch (Dali::DaliException e) {
44335       {
44336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44337       };
44338     } catch (...) {
44339       {
44340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44341       };
44342     }
44343   }
44344
44345 }
44346
44347
44348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44349   void * jresult ;
44350   Dali::LinearConstrainer result;
44351
44352   {
44353     try {
44354       result = Dali::LinearConstrainer::New();
44355     } catch (std::out_of_range& e) {
44356       {
44357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44358       };
44359     } catch (std::exception& e) {
44360       {
44361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44362       };
44363     } catch (Dali::DaliException e) {
44364       {
44365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44366       };
44367     } catch (...) {
44368       {
44369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44370       };
44371     }
44372   }
44373
44374   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44375   return jresult;
44376 }
44377
44378
44379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44380   void * jresult ;
44381   Dali::BaseHandle arg1 ;
44382   Dali::BaseHandle *argp1 ;
44383   Dali::LinearConstrainer result;
44384
44385   argp1 = (Dali::BaseHandle *)jarg1;
44386   if (!argp1) {
44387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44388     return 0;
44389   }
44390   arg1 = *argp1;
44391   {
44392     try {
44393       result = Dali::LinearConstrainer::DownCast(arg1);
44394     } catch (std::out_of_range& e) {
44395       {
44396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44397       };
44398     } catch (std::exception& e) {
44399       {
44400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44401       };
44402     } catch (Dali::DaliException e) {
44403       {
44404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44405       };
44406     } catch (...) {
44407       {
44408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44409       };
44410     }
44411   }
44412
44413   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44414   return jresult;
44415 }
44416
44417
44418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44419   void * jresult ;
44420   Dali::LinearConstrainer *result = 0 ;
44421
44422   {
44423     try {
44424       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44425     } catch (std::out_of_range& e) {
44426       {
44427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44428       };
44429     } catch (std::exception& e) {
44430       {
44431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44432       };
44433     } catch (Dali::DaliException e) {
44434       {
44435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44436       };
44437     } catch (...) {
44438       {
44439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44440       };
44441     }
44442   }
44443
44444   jresult = (void *)result;
44445   return jresult;
44446 }
44447
44448
44449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44450   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44451
44452   arg1 = (Dali::LinearConstrainer *)jarg1;
44453   {
44454     try {
44455       delete arg1;
44456     } catch (std::out_of_range& e) {
44457       {
44458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44459       };
44460     } catch (std::exception& e) {
44461       {
44462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44463       };
44464     } catch (Dali::DaliException e) {
44465       {
44466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44467       };
44468     } catch (...) {
44469       {
44470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44471       };
44472     }
44473   }
44474
44475 }
44476
44477
44478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44479   void * jresult ;
44480   Dali::LinearConstrainer *arg1 = 0 ;
44481   Dali::LinearConstrainer *result = 0 ;
44482
44483   arg1 = (Dali::LinearConstrainer *)jarg1;
44484   if (!arg1) {
44485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44486     return 0;
44487   }
44488   {
44489     try {
44490       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44491     } catch (std::out_of_range& e) {
44492       {
44493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44494       };
44495     } catch (std::exception& e) {
44496       {
44497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44498       };
44499     } catch (Dali::DaliException e) {
44500       {
44501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44502       };
44503     } catch (...) {
44504       {
44505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44506       };
44507     }
44508   }
44509
44510   jresult = (void *)result;
44511   return jresult;
44512 }
44513
44514
44515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44516   void * jresult ;
44517   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44518   Dali::LinearConstrainer *arg2 = 0 ;
44519   Dali::LinearConstrainer *result = 0 ;
44520
44521   arg1 = (Dali::LinearConstrainer *)jarg1;
44522   arg2 = (Dali::LinearConstrainer *)jarg2;
44523   if (!arg2) {
44524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44525     return 0;
44526   }
44527   {
44528     try {
44529       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44530     } catch (std::out_of_range& e) {
44531       {
44532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44533       };
44534     } catch (std::exception& e) {
44535       {
44536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44537       };
44538     } catch (Dali::DaliException e) {
44539       {
44540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44541       };
44542     } catch (...) {
44543       {
44544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44545       };
44546     }
44547   }
44548
44549   jresult = (void *)result;
44550   return jresult;
44551 }
44552
44553
44554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44555   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44556   SwigValueWrapper< Dali::Property > arg2 ;
44557   SwigValueWrapper< Dali::Property > arg3 ;
44558   Dali::Vector2 *arg4 = 0 ;
44559   Dali::Vector2 *arg5 = 0 ;
44560   Dali::Property *argp2 ;
44561   Dali::Property *argp3 ;
44562
44563   arg1 = (Dali::LinearConstrainer *)jarg1;
44564   argp2 = (Dali::Property *)jarg2;
44565   if (!argp2) {
44566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44567     return ;
44568   }
44569   arg2 = *argp2;
44570   argp3 = (Dali::Property *)jarg3;
44571   if (!argp3) {
44572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44573     return ;
44574   }
44575   arg3 = *argp3;
44576   arg4 = (Dali::Vector2 *)jarg4;
44577   if (!arg4) {
44578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44579     return ;
44580   }
44581   arg5 = (Dali::Vector2 *)jarg5;
44582   if (!arg5) {
44583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44584     return ;
44585   }
44586   {
44587     try {
44588       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44589     } catch (std::out_of_range& e) {
44590       {
44591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44592       };
44593     } catch (std::exception& e) {
44594       {
44595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44596       };
44597     } catch (Dali::DaliException e) {
44598       {
44599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44600       };
44601     } catch (...) {
44602       {
44603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44604       };
44605     }
44606   }
44607
44608 }
44609
44610
44611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44612   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44613   SwigValueWrapper< Dali::Property > arg2 ;
44614   SwigValueWrapper< Dali::Property > arg3 ;
44615   Dali::Vector2 *arg4 = 0 ;
44616   Dali::Property *argp2 ;
44617   Dali::Property *argp3 ;
44618
44619   arg1 = (Dali::LinearConstrainer *)jarg1;
44620   argp2 = (Dali::Property *)jarg2;
44621   if (!argp2) {
44622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44623     return ;
44624   }
44625   arg2 = *argp2;
44626   argp3 = (Dali::Property *)jarg3;
44627   if (!argp3) {
44628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44629     return ;
44630   }
44631   arg3 = *argp3;
44632   arg4 = (Dali::Vector2 *)jarg4;
44633   if (!arg4) {
44634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44635     return ;
44636   }
44637   {
44638     try {
44639       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44640     } catch (std::out_of_range& e) {
44641       {
44642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44643       };
44644     } catch (std::exception& e) {
44645       {
44646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44647       };
44648     } catch (Dali::DaliException e) {
44649       {
44650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44651       };
44652     } catch (...) {
44653       {
44654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44655       };
44656     }
44657   }
44658
44659 }
44660
44661
44662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44663   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44664   Dali::Handle *arg2 = 0 ;
44665
44666   arg1 = (Dali::LinearConstrainer *)jarg1;
44667   arg2 = (Dali::Handle *)jarg2;
44668   if (!arg2) {
44669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44670     return ;
44671   }
44672   {
44673     try {
44674       (arg1)->Remove(*arg2);
44675     } catch (std::out_of_range& e) {
44676       {
44677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44678       };
44679     } catch (std::exception& e) {
44680       {
44681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44682       };
44683     } catch (Dali::DaliException e) {
44684       {
44685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44686       };
44687     } catch (...) {
44688       {
44689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44690       };
44691     }
44692   }
44693
44694 }
44695
44696
44697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44698   int jresult ;
44699   int result;
44700
44701   result = (int)Dali::PathConstrainer::Property::FORWARD;
44702   jresult = (int)result;
44703   return jresult;
44704 }
44705
44706
44707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44708   int jresult ;
44709   int result;
44710
44711   result = (int)Dali::PathConstrainer::Property::POINTS;
44712   jresult = (int)result;
44713   return jresult;
44714 }
44715
44716
44717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44718   int jresult ;
44719   int result;
44720
44721   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44722   jresult = (int)result;
44723   return jresult;
44724 }
44725
44726
44727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44728   void * jresult ;
44729   Dali::PathConstrainer::Property *result = 0 ;
44730
44731   {
44732     try {
44733       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44734     } catch (std::out_of_range& e) {
44735       {
44736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44737       };
44738     } catch (std::exception& e) {
44739       {
44740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44741       };
44742     } catch (Dali::DaliException e) {
44743       {
44744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44745       };
44746     } catch (...) {
44747       {
44748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44749       };
44750     }
44751   }
44752
44753   jresult = (void *)result;
44754   return jresult;
44755 }
44756
44757
44758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44759   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44760
44761   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44762   {
44763     try {
44764       delete arg1;
44765     } catch (std::out_of_range& e) {
44766       {
44767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44768       };
44769     } catch (std::exception& e) {
44770       {
44771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44772       };
44773     } catch (Dali::DaliException e) {
44774       {
44775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44776       };
44777     } catch (...) {
44778       {
44779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44780       };
44781     }
44782   }
44783
44784 }
44785
44786
44787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44788   void * jresult ;
44789   Dali::PathConstrainer result;
44790
44791   {
44792     try {
44793       result = Dali::PathConstrainer::New();
44794     } catch (std::out_of_range& e) {
44795       {
44796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44797       };
44798     } catch (std::exception& e) {
44799       {
44800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44801       };
44802     } catch (Dali::DaliException e) {
44803       {
44804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44805       };
44806     } catch (...) {
44807       {
44808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44809       };
44810     }
44811   }
44812
44813   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44814   return jresult;
44815 }
44816
44817
44818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44819   void * jresult ;
44820   Dali::BaseHandle arg1 ;
44821   Dali::BaseHandle *argp1 ;
44822   Dali::PathConstrainer result;
44823
44824   argp1 = (Dali::BaseHandle *)jarg1;
44825   if (!argp1) {
44826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44827     return 0;
44828   }
44829   arg1 = *argp1;
44830   {
44831     try {
44832       result = Dali::PathConstrainer::DownCast(arg1);
44833     } catch (std::out_of_range& e) {
44834       {
44835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44836       };
44837     } catch (std::exception& e) {
44838       {
44839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44840       };
44841     } catch (Dali::DaliException e) {
44842       {
44843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44844       };
44845     } catch (...) {
44846       {
44847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44848       };
44849     }
44850   }
44851
44852   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44853   return jresult;
44854 }
44855
44856
44857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44858   void * jresult ;
44859   Dali::PathConstrainer *result = 0 ;
44860
44861   {
44862     try {
44863       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44864     } catch (std::out_of_range& e) {
44865       {
44866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44867       };
44868     } catch (std::exception& e) {
44869       {
44870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44871       };
44872     } catch (Dali::DaliException e) {
44873       {
44874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44875       };
44876     } catch (...) {
44877       {
44878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44879       };
44880     }
44881   }
44882
44883   jresult = (void *)result;
44884   return jresult;
44885 }
44886
44887
44888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44889   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44890
44891   arg1 = (Dali::PathConstrainer *)jarg1;
44892   {
44893     try {
44894       delete arg1;
44895     } catch (std::out_of_range& e) {
44896       {
44897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44898       };
44899     } catch (std::exception& e) {
44900       {
44901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44902       };
44903     } catch (Dali::DaliException e) {
44904       {
44905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44906       };
44907     } catch (...) {
44908       {
44909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44910       };
44911     }
44912   }
44913
44914 }
44915
44916
44917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44918   void * jresult ;
44919   Dali::PathConstrainer *arg1 = 0 ;
44920   Dali::PathConstrainer *result = 0 ;
44921
44922   arg1 = (Dali::PathConstrainer *)jarg1;
44923   if (!arg1) {
44924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44925     return 0;
44926   }
44927   {
44928     try {
44929       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44930     } catch (std::out_of_range& e) {
44931       {
44932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44933       };
44934     } catch (std::exception& e) {
44935       {
44936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44937       };
44938     } catch (Dali::DaliException e) {
44939       {
44940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44941       };
44942     } catch (...) {
44943       {
44944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44945       };
44946     }
44947   }
44948
44949   jresult = (void *)result;
44950   return jresult;
44951 }
44952
44953
44954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44955   void * jresult ;
44956   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44957   Dali::PathConstrainer *arg2 = 0 ;
44958   Dali::PathConstrainer *result = 0 ;
44959
44960   arg1 = (Dali::PathConstrainer *)jarg1;
44961   arg2 = (Dali::PathConstrainer *)jarg2;
44962   if (!arg2) {
44963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44964     return 0;
44965   }
44966   {
44967     try {
44968       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44969     } catch (std::out_of_range& e) {
44970       {
44971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44972       };
44973     } catch (std::exception& e) {
44974       {
44975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44976       };
44977     } catch (Dali::DaliException e) {
44978       {
44979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44980       };
44981     } catch (...) {
44982       {
44983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44984       };
44985     }
44986   }
44987
44988   jresult = (void *)result;
44989   return jresult;
44990 }
44991
44992
44993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44994   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44995   SwigValueWrapper< Dali::Property > arg2 ;
44996   SwigValueWrapper< Dali::Property > arg3 ;
44997   Dali::Vector2 *arg4 = 0 ;
44998   Dali::Vector2 *arg5 = 0 ;
44999   Dali::Property *argp2 ;
45000   Dali::Property *argp3 ;
45001
45002   arg1 = (Dali::PathConstrainer *)jarg1;
45003   argp2 = (Dali::Property *)jarg2;
45004   if (!argp2) {
45005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
45006     return ;
45007   }
45008   arg2 = *argp2;
45009   argp3 = (Dali::Property *)jarg3;
45010   if (!argp3) {
45011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
45012     return ;
45013   }
45014   arg3 = *argp3;
45015   arg4 = (Dali::Vector2 *)jarg4;
45016   if (!arg4) {
45017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45018     return ;
45019   }
45020   arg5 = (Dali::Vector2 *)jarg5;
45021   if (!arg5) {
45022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45023     return ;
45024   }
45025   {
45026     try {
45027       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
45028     } catch (std::out_of_range& e) {
45029       {
45030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45031       };
45032     } catch (std::exception& e) {
45033       {
45034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45035       };
45036     } catch (Dali::DaliException e) {
45037       {
45038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45039       };
45040     } catch (...) {
45041       {
45042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45043       };
45044     }
45045   }
45046
45047 }
45048
45049
45050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
45051   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
45052   SwigValueWrapper< Dali::Property > arg2 ;
45053   SwigValueWrapper< Dali::Property > arg3 ;
45054   Dali::Vector2 *arg4 = 0 ;
45055   Dali::Property *argp2 ;
45056   Dali::Property *argp3 ;
45057
45058   arg1 = (Dali::PathConstrainer *)jarg1;
45059   argp2 = (Dali::Property *)jarg2;
45060   if (!argp2) {
45061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
45062     return ;
45063   }
45064   arg2 = *argp2;
45065   argp3 = (Dali::Property *)jarg3;
45066   if (!argp3) {
45067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
45068     return ;
45069   }
45070   arg3 = *argp3;
45071   arg4 = (Dali::Vector2 *)jarg4;
45072   if (!arg4) {
45073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45074     return ;
45075   }
45076   {
45077     try {
45078       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
45079     } catch (std::out_of_range& e) {
45080       {
45081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45082       };
45083     } catch (std::exception& e) {
45084       {
45085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45086       };
45087     } catch (Dali::DaliException e) {
45088       {
45089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45090       };
45091     } catch (...) {
45092       {
45093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45094       };
45095     }
45096   }
45097
45098 }
45099
45100
45101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
45102   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
45103   Dali::Handle *arg2 = 0 ;
45104
45105   arg1 = (Dali::PathConstrainer *)jarg1;
45106   arg2 = (Dali::Handle *)jarg2;
45107   if (!arg2) {
45108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
45109     return ;
45110   }
45111   {
45112     try {
45113       (arg1)->Remove(*arg2);
45114     } catch (std::out_of_range& e) {
45115       {
45116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45117       };
45118     } catch (std::exception& e) {
45119       {
45120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45121       };
45122     } catch (Dali::DaliException e) {
45123       {
45124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45125       };
45126     } catch (...) {
45127       {
45128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45129       };
45130     }
45131   }
45132
45133 }
45134
45135
45136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
45137   int jresult ;
45138   Dali::FittingMode::Type result;
45139
45140   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
45141   jresult = (int)result;
45142   return jresult;
45143 }
45144
45145
45146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
45147   int jresult ;
45148   Dali::SamplingMode::Type result;
45149
45150   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
45151   jresult = (int)result;
45152   return jresult;
45153 }
45154
45155
45156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
45157   void * jresult ;
45158   Dali::BufferImage *result = 0 ;
45159
45160   {
45161     try {
45162       result = (Dali::BufferImage *)new Dali::BufferImage();
45163     } catch (std::out_of_range& e) {
45164       {
45165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45166       };
45167     } catch (std::exception& e) {
45168       {
45169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45170       };
45171     } catch (Dali::DaliException e) {
45172       {
45173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45174       };
45175     } catch (...) {
45176       {
45177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45178       };
45179     }
45180   }
45181
45182   jresult = (void *)result;
45183   return jresult;
45184 }
45185
45186
45187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45188   void * jresult ;
45189   unsigned int arg1 ;
45190   unsigned int arg2 ;
45191   Dali::Pixel::Format arg3 ;
45192   Dali::BufferImage result;
45193
45194   arg1 = (unsigned int)jarg1;
45195   arg2 = (unsigned int)jarg2;
45196   arg3 = (Dali::Pixel::Format)jarg3;
45197   {
45198     try {
45199       result = Dali::BufferImage::New(arg1,arg2,arg3);
45200     } catch (std::out_of_range& e) {
45201       {
45202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45203       };
45204     } catch (std::exception& e) {
45205       {
45206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45207       };
45208     } catch (Dali::DaliException e) {
45209       {
45210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45211       };
45212     } catch (...) {
45213       {
45214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45215       };
45216     }
45217   }
45218
45219   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45220   return jresult;
45221 }
45222
45223
45224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45225   void * jresult ;
45226   unsigned int arg1 ;
45227   unsigned int arg2 ;
45228   Dali::BufferImage result;
45229
45230   arg1 = (unsigned int)jarg1;
45231   arg2 = (unsigned int)jarg2;
45232   {
45233     try {
45234       result = Dali::BufferImage::New(arg1,arg2);
45235     } catch (std::out_of_range& e) {
45236       {
45237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45238       };
45239     } catch (std::exception& e) {
45240       {
45241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45242       };
45243     } catch (Dali::DaliException e) {
45244       {
45245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45246       };
45247     } catch (...) {
45248       {
45249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45250       };
45251     }
45252   }
45253
45254   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45255   return jresult;
45256 }
45257
45258
45259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45260   void * jresult ;
45261   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45262   unsigned int arg2 ;
45263   unsigned int arg3 ;
45264   Dali::Pixel::Format arg4 ;
45265   unsigned int arg5 ;
45266   Dali::BufferImage result;
45267
45268   arg1 = jarg1;
45269   arg2 = (unsigned int)jarg2;
45270   arg3 = (unsigned int)jarg3;
45271   arg4 = (Dali::Pixel::Format)jarg4;
45272   arg5 = (unsigned int)jarg5;
45273   {
45274     try {
45275       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45276     } catch (std::out_of_range& e) {
45277       {
45278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45279       };
45280     } catch (std::exception& e) {
45281       {
45282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45283       };
45284     } catch (Dali::DaliException e) {
45285       {
45286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45287       };
45288     } catch (...) {
45289       {
45290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45291       };
45292     }
45293   }
45294
45295   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45296
45297
45298   return jresult;
45299 }
45300
45301
45302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45303   void * jresult ;
45304   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45305   unsigned int arg2 ;
45306   unsigned int arg3 ;
45307   Dali::Pixel::Format arg4 ;
45308   Dali::BufferImage result;
45309
45310   arg1 = jarg1;
45311   arg2 = (unsigned int)jarg2;
45312   arg3 = (unsigned int)jarg3;
45313   arg4 = (Dali::Pixel::Format)jarg4;
45314   {
45315     try {
45316       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45317     } catch (std::out_of_range& e) {
45318       {
45319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45320       };
45321     } catch (std::exception& e) {
45322       {
45323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45324       };
45325     } catch (Dali::DaliException e) {
45326       {
45327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45328       };
45329     } catch (...) {
45330       {
45331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45332       };
45333     }
45334   }
45335
45336   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45337
45338
45339   return jresult;
45340 }
45341
45342
45343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45344   void * jresult ;
45345   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45346   unsigned int arg2 ;
45347   unsigned int arg3 ;
45348   Dali::BufferImage result;
45349
45350   arg1 = jarg1;
45351   arg2 = (unsigned int)jarg2;
45352   arg3 = (unsigned int)jarg3;
45353   {
45354     try {
45355       result = Dali::BufferImage::New(arg1,arg2,arg3);
45356     } catch (std::out_of_range& e) {
45357       {
45358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45359       };
45360     } catch (std::exception& e) {
45361       {
45362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45363       };
45364     } catch (Dali::DaliException e) {
45365       {
45366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45367       };
45368     } catch (...) {
45369       {
45370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45371       };
45372     }
45373   }
45374
45375   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45376
45377
45378   return jresult;
45379 }
45380
45381
45382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45383   void * jresult ;
45384   Dali::BaseHandle arg1 ;
45385   Dali::BaseHandle *argp1 ;
45386   Dali::BufferImage result;
45387
45388   argp1 = (Dali::BaseHandle *)jarg1;
45389   if (!argp1) {
45390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45391     return 0;
45392   }
45393   arg1 = *argp1;
45394   {
45395     try {
45396       result = Dali::BufferImage::DownCast(arg1);
45397     } catch (std::out_of_range& e) {
45398       {
45399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45400       };
45401     } catch (std::exception& e) {
45402       {
45403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45404       };
45405     } catch (Dali::DaliException e) {
45406       {
45407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45408       };
45409     } catch (...) {
45410       {
45411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45412       };
45413     }
45414   }
45415
45416   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45417   return jresult;
45418 }
45419
45420
45421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45422   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45423
45424   arg1 = (Dali::BufferImage *)jarg1;
45425   {
45426     try {
45427       delete arg1;
45428     } catch (std::out_of_range& e) {
45429       {
45430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45431       };
45432     } catch (std::exception& e) {
45433       {
45434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45435       };
45436     } catch (Dali::DaliException e) {
45437       {
45438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45439       };
45440     } catch (...) {
45441       {
45442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45443       };
45444     }
45445   }
45446
45447 }
45448
45449
45450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45451   void * jresult ;
45452   Dali::BufferImage *arg1 = 0 ;
45453   Dali::BufferImage *result = 0 ;
45454
45455   arg1 = (Dali::BufferImage *)jarg1;
45456   if (!arg1) {
45457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45458     return 0;
45459   }
45460   {
45461     try {
45462       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45463     } catch (std::out_of_range& e) {
45464       {
45465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45466       };
45467     } catch (std::exception& e) {
45468       {
45469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45470       };
45471     } catch (Dali::DaliException e) {
45472       {
45473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45474       };
45475     } catch (...) {
45476       {
45477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45478       };
45479     }
45480   }
45481
45482   jresult = (void *)result;
45483   return jresult;
45484 }
45485
45486
45487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45488   void * jresult ;
45489   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45490   Dali::BufferImage *arg2 = 0 ;
45491   Dali::BufferImage *result = 0 ;
45492
45493   arg1 = (Dali::BufferImage *)jarg1;
45494   arg2 = (Dali::BufferImage *)jarg2;
45495   if (!arg2) {
45496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45497     return 0;
45498   }
45499   {
45500     try {
45501       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45502     } catch (std::out_of_range& e) {
45503       {
45504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45505       };
45506     } catch (std::exception& e) {
45507       {
45508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45509       };
45510     } catch (Dali::DaliException e) {
45511       {
45512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45513       };
45514     } catch (...) {
45515       {
45516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45517       };
45518     }
45519   }
45520
45521   jresult = (void *)result;
45522   return jresult;
45523 }
45524
45525
45526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45527   void * jresult ;
45528   Dali::BufferImage result;
45529
45530   {
45531     try {
45532       result = Dali::BufferImage::WHITE();
45533     } catch (std::out_of_range& e) {
45534       {
45535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45536       };
45537     } catch (std::exception& e) {
45538       {
45539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45540       };
45541     } catch (Dali::DaliException e) {
45542       {
45543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45544       };
45545     } catch (...) {
45546       {
45547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45548       };
45549     }
45550   }
45551
45552   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45553   return jresult;
45554 }
45555
45556
45557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45558   void * jresult ;
45559   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45560   Dali::PixelBuffer *result = 0 ;
45561
45562   arg1 = (Dali::BufferImage *)jarg1;
45563   {
45564     try {
45565       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45566     } catch (std::out_of_range& e) {
45567       {
45568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45569       };
45570     } catch (std::exception& e) {
45571       {
45572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45573       };
45574     } catch (Dali::DaliException e) {
45575       {
45576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45577       };
45578     } catch (...) {
45579       {
45580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45581       };
45582     }
45583   }
45584
45585   jresult = (void *)result;
45586   return jresult;
45587 }
45588
45589
45590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45591   unsigned int jresult ;
45592   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45593   unsigned int result;
45594
45595   arg1 = (Dali::BufferImage *)jarg1;
45596   {
45597     try {
45598       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45599     } catch (std::out_of_range& e) {
45600       {
45601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45602       };
45603     } catch (std::exception& e) {
45604       {
45605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45606       };
45607     } catch (Dali::DaliException e) {
45608       {
45609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45610       };
45611     } catch (...) {
45612       {
45613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45614       };
45615     }
45616   }
45617
45618   jresult = result;
45619   return jresult;
45620 }
45621
45622
45623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45624   unsigned int jresult ;
45625   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45626   unsigned int result;
45627
45628   arg1 = (Dali::BufferImage *)jarg1;
45629   {
45630     try {
45631       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45632     } catch (std::out_of_range& e) {
45633       {
45634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45635       };
45636     } catch (std::exception& e) {
45637       {
45638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45639       };
45640     } catch (Dali::DaliException e) {
45641       {
45642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45643       };
45644     } catch (...) {
45645       {
45646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45647       };
45648     }
45649   }
45650
45651   jresult = result;
45652   return jresult;
45653 }
45654
45655
45656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45657   int jresult ;
45658   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45659   Dali::Pixel::Format result;
45660
45661   arg1 = (Dali::BufferImage *)jarg1;
45662   {
45663     try {
45664       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45665     } catch (std::out_of_range& e) {
45666       {
45667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45668       };
45669     } catch (std::exception& e) {
45670       {
45671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45672       };
45673     } catch (Dali::DaliException e) {
45674       {
45675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45676       };
45677     } catch (...) {
45678       {
45679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45680       };
45681     }
45682   }
45683
45684   jresult = (int)result;
45685   return jresult;
45686 }
45687
45688
45689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45690   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45691
45692   arg1 = (Dali::BufferImage *)jarg1;
45693   {
45694     try {
45695       (arg1)->Update();
45696     } catch (std::out_of_range& e) {
45697       {
45698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45699       };
45700     } catch (std::exception& e) {
45701       {
45702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45703       };
45704     } catch (Dali::DaliException e) {
45705       {
45706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45707       };
45708     } catch (...) {
45709       {
45710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45711       };
45712     }
45713   }
45714
45715 }
45716
45717
45718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45719   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45720   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45721   Dali::RectArea *argp2 ;
45722
45723   arg1 = (Dali::BufferImage *)jarg1;
45724   argp2 = (Dali::RectArea *)jarg2;
45725   if (!argp2) {
45726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45727     return ;
45728   }
45729   arg2 = *argp2;
45730   {
45731     try {
45732       (arg1)->Update(arg2);
45733     } catch (std::out_of_range& e) {
45734       {
45735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45736       };
45737     } catch (std::exception& e) {
45738       {
45739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45740       };
45741     } catch (Dali::DaliException e) {
45742       {
45743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45744       };
45745     } catch (...) {
45746       {
45747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45748       };
45749     }
45750   }
45751
45752 }
45753
45754
45755 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45756   unsigned int jresult ;
45757   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45758   bool result;
45759
45760   arg1 = (Dali::BufferImage *)jarg1;
45761   {
45762     try {
45763       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45764     } catch (std::out_of_range& e) {
45765       {
45766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45767       };
45768     } catch (std::exception& e) {
45769       {
45770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45771       };
45772     } catch (Dali::DaliException e) {
45773       {
45774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45775       };
45776     } catch (...) {
45777       {
45778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45779       };
45780     }
45781   }
45782
45783   jresult = result;
45784   return jresult;
45785 }
45786
45787
45788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45789   void * jresult ;
45790   Dali::EncodedBufferImage *result = 0 ;
45791
45792   {
45793     try {
45794       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45795     } catch (std::out_of_range& e) {
45796       {
45797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45798       };
45799     } catch (std::exception& e) {
45800       {
45801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45802       };
45803     } catch (Dali::DaliException e) {
45804       {
45805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45806       };
45807     } catch (...) {
45808       {
45809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45810       };
45811     }
45812   }
45813
45814   jresult = (void *)result;
45815   return jresult;
45816 }
45817
45818
45819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45820   void * jresult ;
45821   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45822   std::size_t arg2 ;
45823   Dali::EncodedBufferImage result;
45824
45825   arg1 = (uint8_t *)jarg1;
45826   arg2 = (std::size_t)jarg2;
45827   {
45828     try {
45829       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45830     } catch (std::out_of_range& e) {
45831       {
45832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45833       };
45834     } catch (std::exception& e) {
45835       {
45836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45837       };
45838     } catch (Dali::DaliException e) {
45839       {
45840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45841       };
45842     } catch (...) {
45843       {
45844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45845       };
45846     }
45847   }
45848
45849   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45850   return jresult;
45851 }
45852
45853
45854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45855   void * jresult ;
45856   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45857   std::size_t arg2 ;
45858   Dali::ImageDimensions arg3 ;
45859   Dali::FittingMode::Type arg4 ;
45860   Dali::SamplingMode::Type arg5 ;
45861   bool arg6 ;
45862   Dali::ImageDimensions *argp3 ;
45863   Dali::EncodedBufferImage result;
45864
45865   arg1 = (uint8_t *)jarg1;
45866   arg2 = (std::size_t)jarg2;
45867   argp3 = (Dali::ImageDimensions *)jarg3;
45868   if (!argp3) {
45869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45870     return 0;
45871   }
45872   arg3 = *argp3;
45873   arg4 = (Dali::FittingMode::Type)jarg4;
45874   arg5 = (Dali::SamplingMode::Type)jarg5;
45875   arg6 = jarg6 ? true : false;
45876   {
45877     try {
45878       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45879     } catch (std::out_of_range& e) {
45880       {
45881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45882       };
45883     } catch (std::exception& e) {
45884       {
45885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45886       };
45887     } catch (Dali::DaliException e) {
45888       {
45889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45890       };
45891     } catch (...) {
45892       {
45893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45894       };
45895     }
45896   }
45897
45898   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45899   return jresult;
45900 }
45901
45902
45903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45904   void * jresult ;
45905   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45906   std::size_t arg2 ;
45907   Dali::ImageDimensions arg3 ;
45908   Dali::FittingMode::Type arg4 ;
45909   Dali::SamplingMode::Type arg5 ;
45910   Dali::ImageDimensions *argp3 ;
45911   Dali::EncodedBufferImage result;
45912
45913   arg1 = (uint8_t *)jarg1;
45914   arg2 = (std::size_t)jarg2;
45915   argp3 = (Dali::ImageDimensions *)jarg3;
45916   if (!argp3) {
45917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45918     return 0;
45919   }
45920   arg3 = *argp3;
45921   arg4 = (Dali::FittingMode::Type)jarg4;
45922   arg5 = (Dali::SamplingMode::Type)jarg5;
45923   {
45924     try {
45925       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45926     } catch (std::out_of_range& e) {
45927       {
45928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45929       };
45930     } catch (std::exception& e) {
45931       {
45932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45933       };
45934     } catch (Dali::DaliException e) {
45935       {
45936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45937       };
45938     } catch (...) {
45939       {
45940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45941       };
45942     }
45943   }
45944
45945   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45946   return jresult;
45947 }
45948
45949
45950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45951   void * jresult ;
45952   Dali::BaseHandle arg1 ;
45953   Dali::BaseHandle *argp1 ;
45954   Dali::EncodedBufferImage result;
45955
45956   argp1 = (Dali::BaseHandle *)jarg1;
45957   if (!argp1) {
45958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45959     return 0;
45960   }
45961   arg1 = *argp1;
45962   {
45963     try {
45964       result = Dali::EncodedBufferImage::DownCast(arg1);
45965     } catch (std::out_of_range& e) {
45966       {
45967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45968       };
45969     } catch (std::exception& e) {
45970       {
45971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45972       };
45973     } catch (Dali::DaliException e) {
45974       {
45975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45976       };
45977     } catch (...) {
45978       {
45979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45980       };
45981     }
45982   }
45983
45984   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45985   return jresult;
45986 }
45987
45988
45989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45990   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45991
45992   arg1 = (Dali::EncodedBufferImage *)jarg1;
45993   {
45994     try {
45995       delete arg1;
45996     } catch (std::out_of_range& e) {
45997       {
45998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45999       };
46000     } catch (std::exception& e) {
46001       {
46002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46003       };
46004     } catch (Dali::DaliException e) {
46005       {
46006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46007       };
46008     } catch (...) {
46009       {
46010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46011       };
46012     }
46013   }
46014
46015 }
46016
46017
46018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
46019   void * jresult ;
46020   Dali::EncodedBufferImage *arg1 = 0 ;
46021   Dali::EncodedBufferImage *result = 0 ;
46022
46023   arg1 = (Dali::EncodedBufferImage *)jarg1;
46024   if (!arg1) {
46025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
46026     return 0;
46027   }
46028   {
46029     try {
46030       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
46031     } catch (std::out_of_range& e) {
46032       {
46033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46034       };
46035     } catch (std::exception& e) {
46036       {
46037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46038       };
46039     } catch (Dali::DaliException e) {
46040       {
46041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46042       };
46043     } catch (...) {
46044       {
46045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46046       };
46047     }
46048   }
46049
46050   jresult = (void *)result;
46051   return jresult;
46052 }
46053
46054
46055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
46056   void * jresult ;
46057   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
46058   Dali::EncodedBufferImage *arg2 = 0 ;
46059   Dali::EncodedBufferImage *result = 0 ;
46060
46061   arg1 = (Dali::EncodedBufferImage *)jarg1;
46062   arg2 = (Dali::EncodedBufferImage *)jarg2;
46063   if (!arg2) {
46064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
46065     return 0;
46066   }
46067   {
46068     try {
46069       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
46070     } catch (std::out_of_range& e) {
46071       {
46072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46073       };
46074     } catch (std::exception& e) {
46075       {
46076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46077       };
46078     } catch (Dali::DaliException e) {
46079       {
46080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46081       };
46082     } catch (...) {
46083       {
46084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46085       };
46086     }
46087   }
46088
46089   jresult = (void *)result;
46090   return jresult;
46091 }
46092
46093
46094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
46095   void * jresult ;
46096   Dali::NativeImage *result = 0 ;
46097
46098   {
46099     try {
46100       result = (Dali::NativeImage *)new Dali::NativeImage();
46101     } catch (std::out_of_range& e) {
46102       {
46103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46104       };
46105     } catch (std::exception& e) {
46106       {
46107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46108       };
46109     } catch (Dali::DaliException e) {
46110       {
46111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46112       };
46113     } catch (...) {
46114       {
46115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46116       };
46117     }
46118   }
46119
46120   jresult = (void *)result;
46121   return jresult;
46122 }
46123
46124
46125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
46126   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46127
46128   arg1 = (Dali::NativeImage *)jarg1;
46129   {
46130     try {
46131       delete arg1;
46132     } catch (std::out_of_range& e) {
46133       {
46134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46135       };
46136     } catch (std::exception& e) {
46137       {
46138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46139       };
46140     } catch (Dali::DaliException e) {
46141       {
46142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46143       };
46144     } catch (...) {
46145       {
46146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46147       };
46148     }
46149   }
46150
46151 }
46152
46153
46154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
46155   void * jresult ;
46156   Dali::NativeImage *arg1 = 0 ;
46157   Dali::NativeImage *result = 0 ;
46158
46159   arg1 = (Dali::NativeImage *)jarg1;
46160   if (!arg1) {
46161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46162     return 0;
46163   }
46164   {
46165     try {
46166       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
46167     } catch (std::out_of_range& e) {
46168       {
46169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46170       };
46171     } catch (std::exception& e) {
46172       {
46173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46174       };
46175     } catch (Dali::DaliException e) {
46176       {
46177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46178       };
46179     } catch (...) {
46180       {
46181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46182       };
46183     }
46184   }
46185
46186   jresult = (void *)result;
46187   return jresult;
46188 }
46189
46190
46191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
46192   void * jresult ;
46193   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46194   Dali::NativeImage *arg2 = 0 ;
46195   Dali::NativeImage *result = 0 ;
46196
46197   arg1 = (Dali::NativeImage *)jarg1;
46198   arg2 = (Dali::NativeImage *)jarg2;
46199   if (!arg2) {
46200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46201     return 0;
46202   }
46203   {
46204     try {
46205       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46206     } catch (std::out_of_range& e) {
46207       {
46208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46209       };
46210     } catch (std::exception& e) {
46211       {
46212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46213       };
46214     } catch (Dali::DaliException e) {
46215       {
46216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46217       };
46218     } catch (...) {
46219       {
46220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46221       };
46222     }
46223   }
46224
46225   jresult = (void *)result;
46226   return jresult;
46227 }
46228
46229
46230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46231   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46232
46233   arg1 = (Dali::NativeImage *)jarg1;
46234   {
46235     try {
46236       (arg1)->CreateGlTexture();
46237     } catch (std::out_of_range& e) {
46238       {
46239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46240       };
46241     } catch (std::exception& e) {
46242       {
46243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46244       };
46245     } catch (Dali::DaliException e) {
46246       {
46247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46248       };
46249     } catch (...) {
46250       {
46251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46252       };
46253     }
46254   }
46255
46256 }
46257
46258
46259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46260   void * jresult ;
46261   NativeImageInterface *arg1 = 0 ;
46262   Dali::NativeImage result;
46263
46264   arg1 = (NativeImageInterface *)jarg1;
46265   if (!arg1) {
46266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46267     return 0;
46268   }
46269   {
46270     try {
46271       result = Dali::NativeImage::New(*arg1);
46272     } catch (std::out_of_range& e) {
46273       {
46274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46275       };
46276     } catch (std::exception& e) {
46277       {
46278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46279       };
46280     } catch (Dali::DaliException e) {
46281       {
46282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46283       };
46284     } catch (...) {
46285       {
46286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46287       };
46288     }
46289   }
46290
46291   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46292   return jresult;
46293 }
46294
46295
46296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46297   void * jresult ;
46298   Dali::BaseHandle arg1 ;
46299   Dali::BaseHandle *argp1 ;
46300   Dali::NativeImage result;
46301
46302   argp1 = (Dali::BaseHandle *)jarg1;
46303   if (!argp1) {
46304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46305     return 0;
46306   }
46307   arg1 = *argp1;
46308   {
46309     try {
46310       result = Dali::NativeImage::DownCast(arg1);
46311     } catch (std::out_of_range& e) {
46312       {
46313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46314       };
46315     } catch (std::exception& e) {
46316       {
46317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46318       };
46319     } catch (Dali::DaliException e) {
46320       {
46321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46322       };
46323     } catch (...) {
46324       {
46325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46326       };
46327     }
46328   }
46329
46330   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46331   return jresult;
46332 }
46333
46334
46335 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46336   char * jresult ;
46337   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46338   char *result = 0 ;
46339
46340   arg1 = (Dali::NativeImage *)jarg1;
46341   {
46342     try {
46343       result = (char *)(arg1)->GetCustomFragmentPreFix();
46344     } catch (std::out_of_range& e) {
46345       {
46346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46347       };
46348     } catch (std::exception& e) {
46349       {
46350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46351       };
46352     } catch (Dali::DaliException e) {
46353       {
46354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46355       };
46356     } catch (...) {
46357       {
46358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46359       };
46360     }
46361   }
46362
46363   jresult = SWIG_csharp_string_callback((const char *)result);
46364   return jresult;
46365 }
46366
46367
46368 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46369   char * jresult ;
46370   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46371   char *result = 0 ;
46372
46373   arg1 = (Dali::NativeImage *)jarg1;
46374   {
46375     try {
46376       result = (char *)(arg1)->GetCustomSamplerTypename();
46377     } catch (std::out_of_range& e) {
46378       {
46379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46380       };
46381     } catch (std::exception& e) {
46382       {
46383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46384       };
46385     } catch (Dali::DaliException e) {
46386       {
46387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46388       };
46389     } catch (...) {
46390       {
46391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46392       };
46393     }
46394   }
46395
46396   jresult = SWIG_csharp_string_callback((const char *)result);
46397   return jresult;
46398 }
46399
46400
46401 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46402   unsigned int jresult ;
46403   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46404   bool result;
46405
46406   arg1 = (Dali::NativeImageInterface *)jarg1;
46407   {
46408     try {
46409       result = (bool)(arg1)->GlExtensionCreate();
46410     } catch (std::out_of_range& e) {
46411       {
46412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46413       };
46414     } catch (std::exception& e) {
46415       {
46416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46417       };
46418     } catch (Dali::DaliException e) {
46419       {
46420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46421       };
46422     } catch (...) {
46423       {
46424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46425       };
46426     }
46427   }
46428
46429   jresult = result;
46430   return jresult;
46431 }
46432
46433
46434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46435   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46436
46437   arg1 = (Dali::NativeImageInterface *)jarg1;
46438   {
46439     try {
46440       (arg1)->GlExtensionDestroy();
46441     } catch (std::out_of_range& e) {
46442       {
46443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46444       };
46445     } catch (std::exception& e) {
46446       {
46447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46448       };
46449     } catch (Dali::DaliException e) {
46450       {
46451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46452       };
46453     } catch (...) {
46454       {
46455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46456       };
46457     }
46458   }
46459
46460 }
46461
46462
46463 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46464   unsigned int jresult ;
46465   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46466   unsigned int result;
46467
46468   arg1 = (Dali::NativeImageInterface *)jarg1;
46469   {
46470     try {
46471       result = (unsigned int)(arg1)->TargetTexture();
46472     } catch (std::out_of_range& e) {
46473       {
46474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46475       };
46476     } catch (std::exception& e) {
46477       {
46478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46479       };
46480     } catch (Dali::DaliException e) {
46481       {
46482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46483       };
46484     } catch (...) {
46485       {
46486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46487       };
46488     }
46489   }
46490
46491   jresult = result;
46492   return jresult;
46493 }
46494
46495
46496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46497   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46498
46499   arg1 = (Dali::NativeImageInterface *)jarg1;
46500   {
46501     try {
46502       (arg1)->PrepareTexture();
46503     } catch (std::out_of_range& e) {
46504       {
46505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46506       };
46507     } catch (std::exception& e) {
46508       {
46509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46510       };
46511     } catch (Dali::DaliException e) {
46512       {
46513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46514       };
46515     } catch (...) {
46516       {
46517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46518       };
46519     }
46520   }
46521
46522 }
46523
46524
46525 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46526   unsigned int jresult ;
46527   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46528   unsigned int result;
46529
46530   arg1 = (Dali::NativeImageInterface *)jarg1;
46531   {
46532     try {
46533       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46534     } catch (std::out_of_range& e) {
46535       {
46536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46537       };
46538     } catch (std::exception& e) {
46539       {
46540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46541       };
46542     } catch (Dali::DaliException e) {
46543       {
46544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46545       };
46546     } catch (...) {
46547       {
46548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46549       };
46550     }
46551   }
46552
46553   jresult = result;
46554   return jresult;
46555 }
46556
46557
46558 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46559   unsigned int jresult ;
46560   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46561   unsigned int result;
46562
46563   arg1 = (Dali::NativeImageInterface *)jarg1;
46564   {
46565     try {
46566       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46567     } catch (std::out_of_range& e) {
46568       {
46569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46570       };
46571     } catch (std::exception& e) {
46572       {
46573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46574       };
46575     } catch (Dali::DaliException e) {
46576       {
46577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46578       };
46579     } catch (...) {
46580       {
46581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46582       };
46583     }
46584   }
46585
46586   jresult = result;
46587   return jresult;
46588 }
46589
46590
46591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46592   unsigned int jresult ;
46593   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46594   bool result;
46595
46596   arg1 = (Dali::NativeImageInterface *)jarg1;
46597   {
46598     try {
46599       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46600     } catch (std::out_of_range& e) {
46601       {
46602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46603       };
46604     } catch (std::exception& e) {
46605       {
46606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46607       };
46608     } catch (Dali::DaliException e) {
46609       {
46610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46611       };
46612     } catch (...) {
46613       {
46614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46615       };
46616     }
46617   }
46618
46619   jresult = result;
46620   return jresult;
46621 }
46622
46623
46624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46625   void * jresult ;
46626   std::string *arg1 = 0 ;
46627   Dali::ImageDimensions result;
46628
46629   if (!jarg1) {
46630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46631     return 0;
46632   }
46633   std::string arg1_str(jarg1);
46634   arg1 = &arg1_str;
46635   {
46636     try {
46637       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46638     } catch (std::out_of_range& e) {
46639       {
46640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46641       };
46642     } catch (std::exception& e) {
46643       {
46644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46645       };
46646     } catch (Dali::DaliException e) {
46647       {
46648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46649       };
46650     } catch (...) {
46651       {
46652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46653       };
46654     }
46655   }
46656
46657   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46658
46659   //argout typemap for const std::string&
46660
46661   return jresult;
46662 }
46663
46664
46665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46666   void * jresult ;
46667   Dali::ResourceImage *result = 0 ;
46668
46669   {
46670     try {
46671       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46672     } catch (std::out_of_range& e) {
46673       {
46674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46675       };
46676     } catch (std::exception& e) {
46677       {
46678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46679       };
46680     } catch (Dali::DaliException e) {
46681       {
46682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46683       };
46684     } catch (...) {
46685       {
46686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46687       };
46688     }
46689   }
46690
46691   jresult = (void *)result;
46692   return jresult;
46693 }
46694
46695
46696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46697   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46698
46699   arg1 = (Dali::ResourceImage *)jarg1;
46700   {
46701     try {
46702       delete arg1;
46703     } catch (std::out_of_range& e) {
46704       {
46705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46706       };
46707     } catch (std::exception& e) {
46708       {
46709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46710       };
46711     } catch (Dali::DaliException e) {
46712       {
46713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46714       };
46715     } catch (...) {
46716       {
46717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46718       };
46719     }
46720   }
46721
46722 }
46723
46724
46725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46726   void * jresult ;
46727   Dali::ResourceImage *arg1 = 0 ;
46728   Dali::ResourceImage *result = 0 ;
46729
46730   arg1 = (Dali::ResourceImage *)jarg1;
46731   if (!arg1) {
46732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46733     return 0;
46734   }
46735   {
46736     try {
46737       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46738     } catch (std::out_of_range& e) {
46739       {
46740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46741       };
46742     } catch (std::exception& e) {
46743       {
46744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46745       };
46746     } catch (Dali::DaliException e) {
46747       {
46748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46749       };
46750     } catch (...) {
46751       {
46752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46753       };
46754     }
46755   }
46756
46757   jresult = (void *)result;
46758   return jresult;
46759 }
46760
46761
46762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46763   void * jresult ;
46764   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46765   Dali::ResourceImage *arg2 = 0 ;
46766   Dali::ResourceImage *result = 0 ;
46767
46768   arg1 = (Dali::ResourceImage *)jarg1;
46769   arg2 = (Dali::ResourceImage *)jarg2;
46770   if (!arg2) {
46771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46772     return 0;
46773   }
46774   {
46775     try {
46776       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46777     } catch (std::out_of_range& e) {
46778       {
46779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46780       };
46781     } catch (std::exception& e) {
46782       {
46783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46784       };
46785     } catch (Dali::DaliException e) {
46786       {
46787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46788       };
46789     } catch (...) {
46790       {
46791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46792       };
46793     }
46794   }
46795
46796   jresult = (void *)result;
46797   return jresult;
46798 }
46799
46800
46801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46802   void * jresult ;
46803   std::string *arg1 = 0 ;
46804   bool arg2 ;
46805   Dali::ResourceImage result;
46806
46807   if (!jarg1) {
46808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46809     return 0;
46810   }
46811   std::string arg1_str(jarg1);
46812   arg1 = &arg1_str;
46813   arg2 = jarg2 ? true : false;
46814   {
46815     try {
46816       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46817     } catch (std::out_of_range& e) {
46818       {
46819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46820       };
46821     } catch (std::exception& e) {
46822       {
46823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46824       };
46825     } catch (Dali::DaliException e) {
46826       {
46827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46828       };
46829     } catch (...) {
46830       {
46831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46832       };
46833     }
46834   }
46835
46836   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46837
46838   //argout typemap for const std::string&
46839
46840   return jresult;
46841 }
46842
46843
46844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46845   void * jresult ;
46846   std::string *arg1 = 0 ;
46847   Dali::ResourceImage result;
46848
46849   if (!jarg1) {
46850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46851     return 0;
46852   }
46853   std::string arg1_str(jarg1);
46854   arg1 = &arg1_str;
46855   {
46856     try {
46857       result = Dali::ResourceImage::New((std::string const &)*arg1);
46858     } catch (std::out_of_range& e) {
46859       {
46860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46861       };
46862     } catch (std::exception& e) {
46863       {
46864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46865       };
46866     } catch (Dali::DaliException e) {
46867       {
46868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46869       };
46870     } catch (...) {
46871       {
46872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46873       };
46874     }
46875   }
46876
46877   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46878
46879   //argout typemap for const std::string&
46880
46881   return jresult;
46882 }
46883
46884
46885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46886   void * jresult ;
46887   std::string *arg1 = 0 ;
46888   Dali::ImageDimensions arg2 ;
46889   Dali::FittingMode::Type arg3 ;
46890   Dali::SamplingMode::Type arg4 ;
46891   bool arg5 ;
46892   Dali::ImageDimensions *argp2 ;
46893   Dali::ResourceImage result;
46894
46895   if (!jarg1) {
46896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46897     return 0;
46898   }
46899   std::string arg1_str(jarg1);
46900   arg1 = &arg1_str;
46901   argp2 = (Dali::ImageDimensions *)jarg2;
46902   if (!argp2) {
46903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46904     return 0;
46905   }
46906   arg2 = *argp2;
46907   arg3 = (Dali::FittingMode::Type)jarg3;
46908   arg4 = (Dali::SamplingMode::Type)jarg4;
46909   arg5 = jarg5 ? true : false;
46910   {
46911     try {
46912       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46913     } catch (std::out_of_range& e) {
46914       {
46915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46916       };
46917     } catch (std::exception& e) {
46918       {
46919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46920       };
46921     } catch (Dali::DaliException e) {
46922       {
46923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46924       };
46925     } catch (...) {
46926       {
46927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46928       };
46929     }
46930   }
46931
46932   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46933
46934   //argout typemap for const std::string&
46935
46936   return jresult;
46937 }
46938
46939
46940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46941   void * jresult ;
46942   std::string *arg1 = 0 ;
46943   Dali::ImageDimensions arg2 ;
46944   Dali::FittingMode::Type arg3 ;
46945   Dali::SamplingMode::Type arg4 ;
46946   Dali::ImageDimensions *argp2 ;
46947   Dali::ResourceImage result;
46948
46949   if (!jarg1) {
46950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46951     return 0;
46952   }
46953   std::string arg1_str(jarg1);
46954   arg1 = &arg1_str;
46955   argp2 = (Dali::ImageDimensions *)jarg2;
46956   if (!argp2) {
46957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46958     return 0;
46959   }
46960   arg2 = *argp2;
46961   arg3 = (Dali::FittingMode::Type)jarg3;
46962   arg4 = (Dali::SamplingMode::Type)jarg4;
46963   {
46964     try {
46965       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46966     } catch (std::out_of_range& e) {
46967       {
46968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46969       };
46970     } catch (std::exception& e) {
46971       {
46972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46973       };
46974     } catch (Dali::DaliException e) {
46975       {
46976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46977       };
46978     } catch (...) {
46979       {
46980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46981       };
46982     }
46983   }
46984
46985   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46986
46987   //argout typemap for const std::string&
46988
46989   return jresult;
46990 }
46991
46992
46993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46994   void * jresult ;
46995   std::string *arg1 = 0 ;
46996   Dali::ImageDimensions arg2 ;
46997   Dali::FittingMode::Type arg3 ;
46998   Dali::ImageDimensions *argp2 ;
46999   Dali::ResourceImage result;
47000
47001   if (!jarg1) {
47002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47003     return 0;
47004   }
47005   std::string arg1_str(jarg1);
47006   arg1 = &arg1_str;
47007   argp2 = (Dali::ImageDimensions *)jarg2;
47008   if (!argp2) {
47009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
47010     return 0;
47011   }
47012   arg2 = *argp2;
47013   arg3 = (Dali::FittingMode::Type)jarg3;
47014   {
47015     try {
47016       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
47017     } catch (std::out_of_range& e) {
47018       {
47019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47020       };
47021     } catch (std::exception& e) {
47022       {
47023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47024       };
47025     } catch (Dali::DaliException e) {
47026       {
47027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47028       };
47029     } catch (...) {
47030       {
47031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47032       };
47033     }
47034   }
47035
47036   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47037
47038   //argout typemap for const std::string&
47039
47040   return jresult;
47041 }
47042
47043
47044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
47045   void * jresult ;
47046   std::string *arg1 = 0 ;
47047   Dali::ImageDimensions arg2 ;
47048   Dali::ImageDimensions *argp2 ;
47049   Dali::ResourceImage result;
47050
47051   if (!jarg1) {
47052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47053     return 0;
47054   }
47055   std::string arg1_str(jarg1);
47056   arg1 = &arg1_str;
47057   argp2 = (Dali::ImageDimensions *)jarg2;
47058   if (!argp2) {
47059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
47060     return 0;
47061   }
47062   arg2 = *argp2;
47063   {
47064     try {
47065       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
47066     } catch (std::out_of_range& e) {
47067       {
47068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47069       };
47070     } catch (std::exception& e) {
47071       {
47072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47073       };
47074     } catch (Dali::DaliException e) {
47075       {
47076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47077       };
47078     } catch (...) {
47079       {
47080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47081       };
47082     }
47083   }
47084
47085   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47086
47087   //argout typemap for const std::string&
47088
47089   return jresult;
47090 }
47091
47092
47093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
47094   void * jresult ;
47095   Dali::BaseHandle arg1 ;
47096   Dali::BaseHandle *argp1 ;
47097   Dali::ResourceImage result;
47098
47099   argp1 = (Dali::BaseHandle *)jarg1;
47100   if (!argp1) {
47101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47102     return 0;
47103   }
47104   arg1 = *argp1;
47105   {
47106     try {
47107       result = Dali::ResourceImage::DownCast(arg1);
47108     } catch (std::out_of_range& e) {
47109       {
47110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47111       };
47112     } catch (std::exception& e) {
47113       {
47114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47115       };
47116     } catch (Dali::DaliException e) {
47117       {
47118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47119       };
47120     } catch (...) {
47121       {
47122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47123       };
47124     }
47125   }
47126
47127   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47128   return jresult;
47129 }
47130
47131
47132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
47133   int jresult ;
47134   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47135   Dali::LoadingState result;
47136
47137   arg1 = (Dali::ResourceImage *)jarg1;
47138   {
47139     try {
47140       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
47141     } catch (std::out_of_range& e) {
47142       {
47143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47144       };
47145     } catch (std::exception& e) {
47146       {
47147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47148       };
47149     } catch (Dali::DaliException e) {
47150       {
47151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47152       };
47153     } catch (...) {
47154       {
47155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47156       };
47157     }
47158   }
47159
47160   jresult = (int)result;
47161   return jresult;
47162 }
47163
47164
47165 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
47166   char * jresult ;
47167   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47168   std::string result;
47169
47170   arg1 = (Dali::ResourceImage *)jarg1;
47171   {
47172     try {
47173       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47174     } catch (std::out_of_range& e) {
47175       {
47176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47177       };
47178     } catch (std::exception& e) {
47179       {
47180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47181       };
47182     } catch (Dali::DaliException e) {
47183       {
47184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47185       };
47186     } catch (...) {
47187       {
47188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47189       };
47190     }
47191   }
47192
47193   jresult = SWIG_csharp_string_callback((&result)->c_str());
47194   return jresult;
47195 }
47196
47197
47198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47199   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47200
47201   arg1 = (Dali::ResourceImage *)jarg1;
47202   {
47203     try {
47204       (arg1)->Reload();
47205     } catch (std::out_of_range& e) {
47206       {
47207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47208       };
47209     } catch (std::exception& e) {
47210       {
47211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47212       };
47213     } catch (Dali::DaliException e) {
47214       {
47215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47216       };
47217     } catch (...) {
47218       {
47219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47220       };
47221     }
47222   }
47223
47224 }
47225
47226
47227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47228   void * jresult ;
47229   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47230   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47231
47232   arg1 = (Dali::ResourceImage *)jarg1;
47233   {
47234     try {
47235       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47236     } catch (std::out_of_range& e) {
47237       {
47238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47239       };
47240     } catch (std::exception& e) {
47241       {
47242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47243       };
47244     } catch (Dali::DaliException e) {
47245       {
47246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47247       };
47248     } catch (...) {
47249       {
47250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47251       };
47252     }
47253   }
47254
47255   jresult = (void *)result;
47256   return jresult;
47257 }
47258
47259
47260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47261   void * jresult ;
47262   Dali::FrameBufferImage *result = 0 ;
47263
47264   {
47265     try {
47266       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47267     } catch (std::out_of_range& e) {
47268       {
47269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47270       };
47271     } catch (std::exception& e) {
47272       {
47273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47274       };
47275     } catch (Dali::DaliException e) {
47276       {
47277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47278       };
47279     } catch (...) {
47280       {
47281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47282       };
47283     }
47284   }
47285
47286   jresult = (void *)result;
47287   return jresult;
47288 }
47289
47290
47291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47292   void * jresult ;
47293   unsigned int arg1 ;
47294   unsigned int arg2 ;
47295   Dali::Pixel::Format arg3 ;
47296   Dali::RenderBuffer::Format arg4 ;
47297   Dali::FrameBufferImage result;
47298
47299   arg1 = (unsigned int)jarg1;
47300   arg2 = (unsigned int)jarg2;
47301   arg3 = (Dali::Pixel::Format)jarg3;
47302   arg4 = (Dali::RenderBuffer::Format)jarg4;
47303   {
47304     try {
47305       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47306     } catch (std::out_of_range& e) {
47307       {
47308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47309       };
47310     } catch (std::exception& e) {
47311       {
47312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47313       };
47314     } catch (Dali::DaliException e) {
47315       {
47316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47317       };
47318     } catch (...) {
47319       {
47320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47321       };
47322     }
47323   }
47324
47325   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47326   return jresult;
47327 }
47328
47329
47330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47331   void * jresult ;
47332   unsigned int arg1 ;
47333   unsigned int arg2 ;
47334   Dali::Pixel::Format arg3 ;
47335   Dali::FrameBufferImage result;
47336
47337   arg1 = (unsigned int)jarg1;
47338   arg2 = (unsigned int)jarg2;
47339   arg3 = (Dali::Pixel::Format)jarg3;
47340   {
47341     try {
47342       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47343     } catch (std::out_of_range& e) {
47344       {
47345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47346       };
47347     } catch (std::exception& e) {
47348       {
47349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47350       };
47351     } catch (Dali::DaliException e) {
47352       {
47353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47354       };
47355     } catch (...) {
47356       {
47357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47358       };
47359     }
47360   }
47361
47362   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47363   return jresult;
47364 }
47365
47366
47367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47368   void * jresult ;
47369   unsigned int arg1 ;
47370   unsigned int arg2 ;
47371   Dali::FrameBufferImage result;
47372
47373   arg1 = (unsigned int)jarg1;
47374   arg2 = (unsigned int)jarg2;
47375   {
47376     try {
47377       result = Dali::FrameBufferImage::New(arg1,arg2);
47378     } catch (std::out_of_range& e) {
47379       {
47380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47381       };
47382     } catch (std::exception& e) {
47383       {
47384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47385       };
47386     } catch (Dali::DaliException e) {
47387       {
47388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47389       };
47390     } catch (...) {
47391       {
47392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47393       };
47394     }
47395   }
47396
47397   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47398   return jresult;
47399 }
47400
47401
47402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47403   void * jresult ;
47404   unsigned int arg1 ;
47405   Dali::FrameBufferImage result;
47406
47407   arg1 = (unsigned int)jarg1;
47408   {
47409     try {
47410       result = Dali::FrameBufferImage::New(arg1);
47411     } catch (std::out_of_range& e) {
47412       {
47413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47414       };
47415     } catch (std::exception& e) {
47416       {
47417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47418       };
47419     } catch (Dali::DaliException e) {
47420       {
47421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47422       };
47423     } catch (...) {
47424       {
47425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47426       };
47427     }
47428   }
47429
47430   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47431   return jresult;
47432 }
47433
47434
47435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47436   void * jresult ;
47437   Dali::FrameBufferImage result;
47438
47439   {
47440     try {
47441       result = Dali::FrameBufferImage::New();
47442     } catch (std::out_of_range& e) {
47443       {
47444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47445       };
47446     } catch (std::exception& e) {
47447       {
47448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47449       };
47450     } catch (Dali::DaliException e) {
47451       {
47452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47453       };
47454     } catch (...) {
47455       {
47456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47457       };
47458     }
47459   }
47460
47461   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47462   return jresult;
47463 }
47464
47465
47466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47467   void * jresult ;
47468   Dali::NativeImageInterface *arg1 = 0 ;
47469   Dali::FrameBufferImage result;
47470
47471   arg1 = (Dali::NativeImageInterface *)jarg1;
47472   if (!arg1) {
47473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47474     return 0;
47475   }
47476   {
47477     try {
47478       result = Dali::FrameBufferImage::New(*arg1);
47479     } catch (std::out_of_range& e) {
47480       {
47481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47482       };
47483     } catch (std::exception& e) {
47484       {
47485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47486       };
47487     } catch (Dali::DaliException e) {
47488       {
47489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47490       };
47491     } catch (...) {
47492       {
47493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47494       };
47495     }
47496   }
47497
47498   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47499   return jresult;
47500 }
47501
47502
47503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47504   void * jresult ;
47505   Dali::BaseHandle arg1 ;
47506   Dali::BaseHandle *argp1 ;
47507   Dali::FrameBufferImage result;
47508
47509   argp1 = (Dali::BaseHandle *)jarg1;
47510   if (!argp1) {
47511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47512     return 0;
47513   }
47514   arg1 = *argp1;
47515   {
47516     try {
47517       result = Dali::FrameBufferImage::DownCast(arg1);
47518     } catch (std::out_of_range& e) {
47519       {
47520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47521       };
47522     } catch (std::exception& e) {
47523       {
47524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47525       };
47526     } catch (Dali::DaliException e) {
47527       {
47528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47529       };
47530     } catch (...) {
47531       {
47532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47533       };
47534     }
47535   }
47536
47537   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47538   return jresult;
47539 }
47540
47541
47542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47543   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47544
47545   arg1 = (Dali::FrameBufferImage *)jarg1;
47546   {
47547     try {
47548       delete arg1;
47549     } catch (std::out_of_range& e) {
47550       {
47551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47552       };
47553     } catch (std::exception& e) {
47554       {
47555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47556       };
47557     } catch (Dali::DaliException e) {
47558       {
47559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47560       };
47561     } catch (...) {
47562       {
47563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47564       };
47565     }
47566   }
47567
47568 }
47569
47570
47571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47572   void * jresult ;
47573   Dali::FrameBufferImage *arg1 = 0 ;
47574   Dali::FrameBufferImage *result = 0 ;
47575
47576   arg1 = (Dali::FrameBufferImage *)jarg1;
47577   if (!arg1) {
47578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47579     return 0;
47580   }
47581   {
47582     try {
47583       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47584     } catch (std::out_of_range& e) {
47585       {
47586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47587       };
47588     } catch (std::exception& e) {
47589       {
47590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47591       };
47592     } catch (Dali::DaliException e) {
47593       {
47594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47595       };
47596     } catch (...) {
47597       {
47598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47599       };
47600     }
47601   }
47602
47603   jresult = (void *)result;
47604   return jresult;
47605 }
47606
47607
47608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47609   void * jresult ;
47610   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47611   Dali::FrameBufferImage *arg2 = 0 ;
47612   Dali::FrameBufferImage *result = 0 ;
47613
47614   arg1 = (Dali::FrameBufferImage *)jarg1;
47615   arg2 = (Dali::FrameBufferImage *)jarg2;
47616   if (!arg2) {
47617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47618     return 0;
47619   }
47620   {
47621     try {
47622       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47623     } catch (std::out_of_range& e) {
47624       {
47625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47626       };
47627     } catch (std::exception& e) {
47628       {
47629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47630       };
47631     } catch (Dali::DaliException e) {
47632       {
47633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47634       };
47635     } catch (...) {
47636       {
47637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47638       };
47639     }
47640   }
47641
47642   jresult = (void *)result;
47643   return jresult;
47644 }
47645
47646
47647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47648   void * jresult ;
47649   Dali::NinePatchImage *result = 0 ;
47650
47651   {
47652     try {
47653       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47654     } catch (std::out_of_range& e) {
47655       {
47656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47657       };
47658     } catch (std::exception& e) {
47659       {
47660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47661       };
47662     } catch (Dali::DaliException e) {
47663       {
47664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47665       };
47666     } catch (...) {
47667       {
47668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47669       };
47670     }
47671   }
47672
47673   jresult = (void *)result;
47674   return jresult;
47675 }
47676
47677
47678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47679   void * jresult ;
47680   std::string *arg1 = 0 ;
47681   Dali::NinePatchImage result;
47682
47683   if (!jarg1) {
47684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47685     return 0;
47686   }
47687   std::string arg1_str(jarg1);
47688   arg1 = &arg1_str;
47689   {
47690     try {
47691       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47692     } catch (std::out_of_range& e) {
47693       {
47694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47695       };
47696     } catch (std::exception& e) {
47697       {
47698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47699       };
47700     } catch (Dali::DaliException e) {
47701       {
47702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47703       };
47704     } catch (...) {
47705       {
47706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47707       };
47708     }
47709   }
47710
47711   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47712
47713   //argout typemap for const std::string&
47714
47715   return jresult;
47716 }
47717
47718
47719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47720   void * jresult ;
47721   Dali::BaseHandle arg1 ;
47722   Dali::BaseHandle *argp1 ;
47723   Dali::NinePatchImage result;
47724
47725   argp1 = (Dali::BaseHandle *)jarg1;
47726   if (!argp1) {
47727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47728     return 0;
47729   }
47730   arg1 = *argp1;
47731   {
47732     try {
47733       result = Dali::NinePatchImage::DownCast(arg1);
47734     } catch (std::out_of_range& e) {
47735       {
47736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47737       };
47738     } catch (std::exception& e) {
47739       {
47740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47741       };
47742     } catch (Dali::DaliException e) {
47743       {
47744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47745       };
47746     } catch (...) {
47747       {
47748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47749       };
47750     }
47751   }
47752
47753   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47754   return jresult;
47755 }
47756
47757
47758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47759   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47760
47761   arg1 = (Dali::NinePatchImage *)jarg1;
47762   {
47763     try {
47764       delete arg1;
47765     } catch (std::out_of_range& e) {
47766       {
47767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47768       };
47769     } catch (std::exception& e) {
47770       {
47771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47772       };
47773     } catch (Dali::DaliException e) {
47774       {
47775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47776       };
47777     } catch (...) {
47778       {
47779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47780       };
47781     }
47782   }
47783
47784 }
47785
47786
47787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47788   void * jresult ;
47789   Dali::NinePatchImage *arg1 = 0 ;
47790   Dali::NinePatchImage *result = 0 ;
47791
47792   arg1 = (Dali::NinePatchImage *)jarg1;
47793   if (!arg1) {
47794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47795     return 0;
47796   }
47797   {
47798     try {
47799       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47800     } catch (std::out_of_range& e) {
47801       {
47802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47803       };
47804     } catch (std::exception& e) {
47805       {
47806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47807       };
47808     } catch (Dali::DaliException e) {
47809       {
47810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47811       };
47812     } catch (...) {
47813       {
47814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47815       };
47816     }
47817   }
47818
47819   jresult = (void *)result;
47820   return jresult;
47821 }
47822
47823
47824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47825   void * jresult ;
47826   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47827   Dali::NinePatchImage *arg2 = 0 ;
47828   Dali::NinePatchImage *result = 0 ;
47829
47830   arg1 = (Dali::NinePatchImage *)jarg1;
47831   arg2 = (Dali::NinePatchImage *)jarg2;
47832   if (!arg2) {
47833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47834     return 0;
47835   }
47836   {
47837     try {
47838       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47839     } catch (std::out_of_range& e) {
47840       {
47841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47842       };
47843     } catch (std::exception& e) {
47844       {
47845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47846       };
47847     } catch (Dali::DaliException e) {
47848       {
47849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47850       };
47851     } catch (...) {
47852       {
47853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47854       };
47855     }
47856   }
47857
47858   jresult = (void *)result;
47859   return jresult;
47860 }
47861
47862
47863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47864   void * jresult ;
47865   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47866   Dali::Vector4 result;
47867
47868   arg1 = (Dali::NinePatchImage *)jarg1;
47869   {
47870     try {
47871       result = (arg1)->GetStretchBorders();
47872     } catch (std::out_of_range& e) {
47873       {
47874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47875       };
47876     } catch (std::exception& e) {
47877       {
47878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47879       };
47880     } catch (Dali::DaliException e) {
47881       {
47882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47883       };
47884     } catch (...) {
47885       {
47886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47887       };
47888     }
47889   }
47890
47891   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47892   return jresult;
47893 }
47894
47895
47896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47897   void * jresult ;
47898   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47899   Dali::NinePatchImage::StretchRanges *result = 0 ;
47900
47901   arg1 = (Dali::NinePatchImage *)jarg1;
47902   {
47903     try {
47904       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47905     } catch (std::out_of_range& e) {
47906       {
47907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47908       };
47909     } catch (std::exception& e) {
47910       {
47911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47912       };
47913     } catch (Dali::DaliException e) {
47914       {
47915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47916       };
47917     } catch (...) {
47918       {
47919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47920       };
47921     }
47922   }
47923
47924   jresult = (void *)result;
47925   return jresult;
47926 }
47927
47928
47929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47930   void * jresult ;
47931   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47932   Dali::NinePatchImage::StretchRanges *result = 0 ;
47933
47934   arg1 = (Dali::NinePatchImage *)jarg1;
47935   {
47936     try {
47937       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47938     } catch (std::out_of_range& e) {
47939       {
47940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47941       };
47942     } catch (std::exception& e) {
47943       {
47944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47945       };
47946     } catch (Dali::DaliException e) {
47947       {
47948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47949       };
47950     } catch (...) {
47951       {
47952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47953       };
47954     }
47955   }
47956
47957   jresult = (void *)result;
47958   return jresult;
47959 }
47960
47961
47962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47963   void * jresult ;
47964   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47965   Dali::Rect< int > result;
47966
47967   arg1 = (Dali::NinePatchImage *)jarg1;
47968   {
47969     try {
47970       result = (arg1)->GetChildRectangle();
47971     } catch (std::out_of_range& e) {
47972       {
47973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47974       };
47975     } catch (std::exception& e) {
47976       {
47977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47978       };
47979     } catch (Dali::DaliException e) {
47980       {
47981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47982       };
47983     } catch (...) {
47984       {
47985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47986       };
47987     }
47988   }
47989
47990   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47991   return jresult;
47992 }
47993
47994
47995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47996   void * jresult ;
47997   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47998   Dali::BufferImage result;
47999
48000   arg1 = (Dali::NinePatchImage *)jarg1;
48001   {
48002     try {
48003       result = (arg1)->CreateCroppedBufferImage();
48004     } catch (std::out_of_range& e) {
48005       {
48006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48007       };
48008     } catch (std::exception& e) {
48009       {
48010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48011       };
48012     } catch (Dali::DaliException e) {
48013       {
48014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48015       };
48016     } catch (...) {
48017       {
48018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48019       };
48020     }
48021   }
48022
48023   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
48024   return jresult;
48025 }
48026
48027
48028 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
48029   unsigned int jresult ;
48030   std::string *arg1 = 0 ;
48031   bool result;
48032
48033   if (!jarg1) {
48034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48035     return 0;
48036   }
48037   std::string arg1_str(jarg1);
48038   arg1 = &arg1_str;
48039   {
48040     try {
48041       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
48042     } catch (std::out_of_range& e) {
48043       {
48044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48045       };
48046     } catch (std::exception& e) {
48047       {
48048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48049       };
48050     } catch (Dali::DaliException e) {
48051       {
48052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48053       };
48054     } catch (...) {
48055       {
48056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48057       };
48058     }
48059   }
48060
48061   jresult = result;
48062
48063   //argout typemap for const std::string&
48064
48065   return jresult;
48066 }
48067
48068
48069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
48070   int jresult ;
48071   int result;
48072
48073   result = (int)Dali::CameraActor::Property::TYPE;
48074   jresult = (int)result;
48075   return jresult;
48076 }
48077
48078
48079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
48080   int jresult ;
48081   int result;
48082
48083   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
48084   jresult = (int)result;
48085   return jresult;
48086 }
48087
48088
48089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
48090   int jresult ;
48091   int result;
48092
48093   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
48094   jresult = (int)result;
48095   return jresult;
48096 }
48097
48098
48099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
48100   int jresult ;
48101   int result;
48102
48103   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
48104   jresult = (int)result;
48105   return jresult;
48106 }
48107
48108
48109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
48110   int jresult ;
48111   int result;
48112
48113   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
48114   jresult = (int)result;
48115   return jresult;
48116 }
48117
48118
48119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
48120   int jresult ;
48121   int result;
48122
48123   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
48124   jresult = (int)result;
48125   return jresult;
48126 }
48127
48128
48129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
48130   int jresult ;
48131   int result;
48132
48133   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
48134   jresult = (int)result;
48135   return jresult;
48136 }
48137
48138
48139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
48140   int jresult ;
48141   int result;
48142
48143   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
48144   jresult = (int)result;
48145   return jresult;
48146 }
48147
48148
48149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
48150   int jresult ;
48151   int result;
48152
48153   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
48154   jresult = (int)result;
48155   return jresult;
48156 }
48157
48158
48159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
48160   int jresult ;
48161   int result;
48162
48163   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
48164   jresult = (int)result;
48165   return jresult;
48166 }
48167
48168
48169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
48170   int jresult ;
48171   int result;
48172
48173   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48174   jresult = (int)result;
48175   return jresult;
48176 }
48177
48178
48179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48180   int jresult ;
48181   int result;
48182
48183   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48184   jresult = (int)result;
48185   return jresult;
48186 }
48187
48188
48189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48190   int jresult ;
48191   int result;
48192
48193   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48194   jresult = (int)result;
48195   return jresult;
48196 }
48197
48198
48199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48200   int jresult ;
48201   int result;
48202
48203   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48204   jresult = (int)result;
48205   return jresult;
48206 }
48207
48208
48209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48210   void * jresult ;
48211   Dali::CameraActor::Property *result = 0 ;
48212
48213   {
48214     try {
48215       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48216     } catch (std::out_of_range& e) {
48217       {
48218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48219       };
48220     } catch (std::exception& e) {
48221       {
48222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48223       };
48224     } catch (Dali::DaliException e) {
48225       {
48226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48227       };
48228     } catch (...) {
48229       {
48230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48231       };
48232     }
48233   }
48234
48235   jresult = (void *)result;
48236   return jresult;
48237 }
48238
48239
48240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48241   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48242
48243   arg1 = (Dali::CameraActor::Property *)jarg1;
48244   {
48245     try {
48246       delete arg1;
48247     } catch (std::out_of_range& e) {
48248       {
48249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48250       };
48251     } catch (std::exception& e) {
48252       {
48253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48254       };
48255     } catch (Dali::DaliException e) {
48256       {
48257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48258       };
48259     } catch (...) {
48260       {
48261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48262       };
48263     }
48264   }
48265
48266 }
48267
48268
48269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48270   void * jresult ;
48271   Dali::CameraActor *result = 0 ;
48272
48273   {
48274     try {
48275       result = (Dali::CameraActor *)new Dali::CameraActor();
48276     } catch (std::out_of_range& e) {
48277       {
48278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48279       };
48280     } catch (std::exception& e) {
48281       {
48282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48283       };
48284     } catch (Dali::DaliException e) {
48285       {
48286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48287       };
48288     } catch (...) {
48289       {
48290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48291       };
48292     }
48293   }
48294
48295   jresult = (void *)result;
48296   return jresult;
48297 }
48298
48299
48300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48301   void * jresult ;
48302   Dali::CameraActor result;
48303
48304   {
48305     try {
48306       result = Dali::CameraActor::New();
48307     } catch (std::out_of_range& e) {
48308       {
48309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48310       };
48311     } catch (std::exception& e) {
48312       {
48313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48314       };
48315     } catch (Dali::DaliException e) {
48316       {
48317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48318       };
48319     } catch (...) {
48320       {
48321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48322       };
48323     }
48324   }
48325
48326   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48327   return jresult;
48328 }
48329
48330
48331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48332   void * jresult ;
48333   Dali::Size *arg1 = 0 ;
48334   Dali::CameraActor result;
48335
48336   arg1 = (Dali::Size *)jarg1;
48337   if (!arg1) {
48338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48339     return 0;
48340   }
48341   {
48342     try {
48343       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48344     } catch (std::out_of_range& e) {
48345       {
48346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48347       };
48348     } catch (std::exception& e) {
48349       {
48350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48351       };
48352     } catch (Dali::DaliException e) {
48353       {
48354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48355       };
48356     } catch (...) {
48357       {
48358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48359       };
48360     }
48361   }
48362
48363   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48364   return jresult;
48365 }
48366
48367
48368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48369   void * jresult ;
48370   Dali::BaseHandle arg1 ;
48371   Dali::BaseHandle *argp1 ;
48372   Dali::CameraActor result;
48373
48374   argp1 = (Dali::BaseHandle *)jarg1;
48375   if (!argp1) {
48376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48377     return 0;
48378   }
48379   arg1 = *argp1;
48380   {
48381     try {
48382       result = Dali::CameraActor::DownCast(arg1);
48383     } catch (std::out_of_range& e) {
48384       {
48385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48386       };
48387     } catch (std::exception& e) {
48388       {
48389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48390       };
48391     } catch (Dali::DaliException e) {
48392       {
48393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48394       };
48395     } catch (...) {
48396       {
48397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48398       };
48399     }
48400   }
48401
48402   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48403   return jresult;
48404 }
48405
48406
48407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48408   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48409
48410   arg1 = (Dali::CameraActor *)jarg1;
48411   {
48412     try {
48413       delete arg1;
48414     } catch (std::out_of_range& e) {
48415       {
48416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48417       };
48418     } catch (std::exception& e) {
48419       {
48420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48421       };
48422     } catch (Dali::DaliException e) {
48423       {
48424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48425       };
48426     } catch (...) {
48427       {
48428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48429       };
48430     }
48431   }
48432
48433 }
48434
48435
48436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48437   void * jresult ;
48438   Dali::CameraActor *arg1 = 0 ;
48439   Dali::CameraActor *result = 0 ;
48440
48441   arg1 = (Dali::CameraActor *)jarg1;
48442   if (!arg1) {
48443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48444     return 0;
48445   }
48446   {
48447     try {
48448       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48449     } catch (std::out_of_range& e) {
48450       {
48451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48452       };
48453     } catch (std::exception& e) {
48454       {
48455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48456       };
48457     } catch (Dali::DaliException e) {
48458       {
48459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48460       };
48461     } catch (...) {
48462       {
48463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48464       };
48465     }
48466   }
48467
48468   jresult = (void *)result;
48469   return jresult;
48470 }
48471
48472
48473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48474   void * jresult ;
48475   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48476   Dali::CameraActor *arg2 = 0 ;
48477   Dali::CameraActor *result = 0 ;
48478
48479   arg1 = (Dali::CameraActor *)jarg1;
48480   arg2 = (Dali::CameraActor *)jarg2;
48481   if (!arg2) {
48482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48483     return 0;
48484   }
48485   {
48486     try {
48487       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48488     } catch (std::out_of_range& e) {
48489       {
48490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48491       };
48492     } catch (std::exception& e) {
48493       {
48494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48495       };
48496     } catch (Dali::DaliException e) {
48497       {
48498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48499       };
48500     } catch (...) {
48501       {
48502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48503       };
48504     }
48505   }
48506
48507   jresult = (void *)result;
48508   return jresult;
48509 }
48510
48511
48512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48513   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48514   Dali::Camera::Type arg2 ;
48515
48516   arg1 = (Dali::CameraActor *)jarg1;
48517   arg2 = (Dali::Camera::Type)jarg2;
48518   {
48519     try {
48520       (arg1)->SetType(arg2);
48521     } catch (std::out_of_range& e) {
48522       {
48523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48524       };
48525     } catch (std::exception& e) {
48526       {
48527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48528       };
48529     } catch (Dali::DaliException e) {
48530       {
48531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48532       };
48533     } catch (...) {
48534       {
48535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48536       };
48537     }
48538   }
48539
48540 }
48541
48542
48543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48544   int jresult ;
48545   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48546   Dali::Camera::Type result;
48547
48548   arg1 = (Dali::CameraActor *)jarg1;
48549   {
48550     try {
48551       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48552     } catch (std::out_of_range& e) {
48553       {
48554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48555       };
48556     } catch (std::exception& e) {
48557       {
48558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48559       };
48560     } catch (Dali::DaliException e) {
48561       {
48562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48563       };
48564     } catch (...) {
48565       {
48566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48567       };
48568     }
48569   }
48570
48571   jresult = (int)result;
48572   return jresult;
48573 }
48574
48575
48576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48577   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48578   Dali::Camera::ProjectionMode arg2 ;
48579
48580   arg1 = (Dali::CameraActor *)jarg1;
48581   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48582   {
48583     try {
48584       (arg1)->SetProjectionMode(arg2);
48585     } catch (std::out_of_range& e) {
48586       {
48587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48588       };
48589     } catch (std::exception& e) {
48590       {
48591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48592       };
48593     } catch (Dali::DaliException e) {
48594       {
48595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48596       };
48597     } catch (...) {
48598       {
48599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48600       };
48601     }
48602   }
48603
48604 }
48605
48606
48607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48608   int jresult ;
48609   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48610   Dali::Camera::ProjectionMode result;
48611
48612   arg1 = (Dali::CameraActor *)jarg1;
48613   {
48614     try {
48615       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48616     } catch (std::out_of_range& e) {
48617       {
48618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48619       };
48620     } catch (std::exception& e) {
48621       {
48622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48623       };
48624     } catch (Dali::DaliException e) {
48625       {
48626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48627       };
48628     } catch (...) {
48629       {
48630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48631       };
48632     }
48633   }
48634
48635   jresult = (int)result;
48636   return jresult;
48637 }
48638
48639
48640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48641   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48642   float arg2 ;
48643
48644   arg1 = (Dali::CameraActor *)jarg1;
48645   arg2 = (float)jarg2;
48646   {
48647     try {
48648       (arg1)->SetFieldOfView(arg2);
48649     } catch (std::out_of_range& e) {
48650       {
48651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48652       };
48653     } catch (std::exception& e) {
48654       {
48655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48656       };
48657     } catch (Dali::DaliException e) {
48658       {
48659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48660       };
48661     } catch (...) {
48662       {
48663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48664       };
48665     }
48666   }
48667
48668 }
48669
48670
48671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48672   float jresult ;
48673   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48674   float result;
48675
48676   arg1 = (Dali::CameraActor *)jarg1;
48677   {
48678     try {
48679       result = (float)(arg1)->GetFieldOfView();
48680     } catch (std::out_of_range& e) {
48681       {
48682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48683       };
48684     } catch (std::exception& e) {
48685       {
48686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48687       };
48688     } catch (Dali::DaliException e) {
48689       {
48690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48691       };
48692     } catch (...) {
48693       {
48694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48695       };
48696     }
48697   }
48698
48699   jresult = result;
48700   return jresult;
48701 }
48702
48703
48704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48705   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48706   float arg2 ;
48707
48708   arg1 = (Dali::CameraActor *)jarg1;
48709   arg2 = (float)jarg2;
48710   {
48711     try {
48712       (arg1)->SetAspectRatio(arg2);
48713     } catch (std::out_of_range& e) {
48714       {
48715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48716       };
48717     } catch (std::exception& e) {
48718       {
48719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48720       };
48721     } catch (Dali::DaliException e) {
48722       {
48723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48724       };
48725     } catch (...) {
48726       {
48727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48728       };
48729     }
48730   }
48731
48732 }
48733
48734
48735 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48736   float jresult ;
48737   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48738   float result;
48739
48740   arg1 = (Dali::CameraActor *)jarg1;
48741   {
48742     try {
48743       result = (float)(arg1)->GetAspectRatio();
48744     } catch (std::out_of_range& e) {
48745       {
48746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48747       };
48748     } catch (std::exception& e) {
48749       {
48750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48751       };
48752     } catch (Dali::DaliException e) {
48753       {
48754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48755       };
48756     } catch (...) {
48757       {
48758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48759       };
48760     }
48761   }
48762
48763   jresult = result;
48764   return jresult;
48765 }
48766
48767
48768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48769   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48770   float arg2 ;
48771
48772   arg1 = (Dali::CameraActor *)jarg1;
48773   arg2 = (float)jarg2;
48774   {
48775     try {
48776       (arg1)->SetNearClippingPlane(arg2);
48777     } catch (std::out_of_range& e) {
48778       {
48779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48780       };
48781     } catch (std::exception& e) {
48782       {
48783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48784       };
48785     } catch (Dali::DaliException e) {
48786       {
48787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48788       };
48789     } catch (...) {
48790       {
48791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48792       };
48793     }
48794   }
48795
48796 }
48797
48798
48799 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48800   float jresult ;
48801   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48802   float result;
48803
48804   arg1 = (Dali::CameraActor *)jarg1;
48805   {
48806     try {
48807       result = (float)(arg1)->GetNearClippingPlane();
48808     } catch (std::out_of_range& e) {
48809       {
48810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48811       };
48812     } catch (std::exception& e) {
48813       {
48814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48815       };
48816     } catch (Dali::DaliException e) {
48817       {
48818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48819       };
48820     } catch (...) {
48821       {
48822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48823       };
48824     }
48825   }
48826
48827   jresult = result;
48828   return jresult;
48829 }
48830
48831
48832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48833   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48834   float arg2 ;
48835
48836   arg1 = (Dali::CameraActor *)jarg1;
48837   arg2 = (float)jarg2;
48838   {
48839     try {
48840       (arg1)->SetFarClippingPlane(arg2);
48841     } catch (std::out_of_range& e) {
48842       {
48843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48844       };
48845     } catch (std::exception& e) {
48846       {
48847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48848       };
48849     } catch (Dali::DaliException e) {
48850       {
48851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48852       };
48853     } catch (...) {
48854       {
48855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48856       };
48857     }
48858   }
48859
48860 }
48861
48862
48863 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48864   float jresult ;
48865   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48866   float result;
48867
48868   arg1 = (Dali::CameraActor *)jarg1;
48869   {
48870     try {
48871       result = (float)(arg1)->GetFarClippingPlane();
48872     } catch (std::out_of_range& e) {
48873       {
48874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48875       };
48876     } catch (std::exception& e) {
48877       {
48878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48879       };
48880     } catch (Dali::DaliException e) {
48881       {
48882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48883       };
48884     } catch (...) {
48885       {
48886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48887       };
48888     }
48889   }
48890
48891   jresult = result;
48892   return jresult;
48893 }
48894
48895
48896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48897   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48898   Dali::Vector3 *arg2 = 0 ;
48899
48900   arg1 = (Dali::CameraActor *)jarg1;
48901   arg2 = (Dali::Vector3 *)jarg2;
48902   if (!arg2) {
48903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48904     return ;
48905   }
48906   {
48907     try {
48908       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48909     } catch (std::out_of_range& e) {
48910       {
48911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48912       };
48913     } catch (std::exception& e) {
48914       {
48915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48916       };
48917     } catch (Dali::DaliException e) {
48918       {
48919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48920       };
48921     } catch (...) {
48922       {
48923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48924       };
48925     }
48926   }
48927
48928 }
48929
48930
48931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48932   void * jresult ;
48933   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48934   Dali::Vector3 result;
48935
48936   arg1 = (Dali::CameraActor *)jarg1;
48937   {
48938     try {
48939       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48940     } catch (std::out_of_range& e) {
48941       {
48942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48943       };
48944     } catch (std::exception& e) {
48945       {
48946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48947       };
48948     } catch (Dali::DaliException e) {
48949       {
48950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48951       };
48952     } catch (...) {
48953       {
48954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48955       };
48956     }
48957   }
48958
48959   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48960   return jresult;
48961 }
48962
48963
48964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48965   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48966   bool arg2 ;
48967
48968   arg1 = (Dali::CameraActor *)jarg1;
48969   arg2 = jarg2 ? true : false;
48970   {
48971     try {
48972       (arg1)->SetInvertYAxis(arg2);
48973     } catch (std::out_of_range& e) {
48974       {
48975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48976       };
48977     } catch (std::exception& e) {
48978       {
48979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48980       };
48981     } catch (Dali::DaliException e) {
48982       {
48983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48984       };
48985     } catch (...) {
48986       {
48987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48988       };
48989     }
48990   }
48991
48992 }
48993
48994
48995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48996   unsigned int jresult ;
48997   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48998   bool result;
48999
49000   arg1 = (Dali::CameraActor *)jarg1;
49001   {
49002     try {
49003       result = (bool)(arg1)->GetInvertYAxis();
49004     } catch (std::out_of_range& e) {
49005       {
49006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49007       };
49008     } catch (std::exception& e) {
49009       {
49010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49011       };
49012     } catch (Dali::DaliException e) {
49013       {
49014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49015       };
49016     } catch (...) {
49017       {
49018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49019       };
49020     }
49021   }
49022
49023   jresult = result;
49024   return jresult;
49025 }
49026
49027
49028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
49029   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
49030   Dali::Size *arg2 = 0 ;
49031
49032   arg1 = (Dali::CameraActor *)jarg1;
49033   arg2 = (Dali::Size *)jarg2;
49034   if (!arg2) {
49035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
49036     return ;
49037   }
49038   {
49039     try {
49040       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
49041     } catch (std::out_of_range& e) {
49042       {
49043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49044       };
49045     } catch (std::exception& e) {
49046       {
49047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49048       };
49049     } catch (Dali::DaliException e) {
49050       {
49051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49052       };
49053     } catch (...) {
49054       {
49055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49056       };
49057     }
49058   }
49059
49060 }
49061
49062
49063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
49064   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
49065   Dali::Size *arg2 = 0 ;
49066
49067   arg1 = (Dali::CameraActor *)jarg1;
49068   arg2 = (Dali::Size *)jarg2;
49069   if (!arg2) {
49070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
49071     return ;
49072   }
49073   {
49074     try {
49075       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
49076     } catch (std::out_of_range& e) {
49077       {
49078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49079       };
49080     } catch (std::exception& e) {
49081       {
49082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49083       };
49084     } catch (Dali::DaliException e) {
49085       {
49086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49087       };
49088     } catch (...) {
49089       {
49090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49091       };
49092     }
49093   }
49094
49095 }
49096
49097
49098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
49099   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
49100   float arg2 ;
49101   float arg3 ;
49102   float arg4 ;
49103   float arg5 ;
49104   float arg6 ;
49105   float arg7 ;
49106
49107   arg1 = (Dali::CameraActor *)jarg1;
49108   arg2 = (float)jarg2;
49109   arg3 = (float)jarg3;
49110   arg4 = (float)jarg4;
49111   arg5 = (float)jarg5;
49112   arg6 = (float)jarg6;
49113   arg7 = (float)jarg7;
49114   {
49115     try {
49116       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
49117     } catch (std::out_of_range& e) {
49118       {
49119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49120       };
49121     } catch (std::exception& e) {
49122       {
49123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49124       };
49125     } catch (Dali::DaliException e) {
49126       {
49127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49128       };
49129     } catch (...) {
49130       {
49131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49132       };
49133     }
49134   }
49135
49136 }
49137
49138
49139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
49140   void * jresult ;
49141   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49142
49143   {
49144     try {
49145       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
49146     } catch (std::out_of_range& e) {
49147       {
49148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49149       };
49150     } catch (std::exception& e) {
49151       {
49152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49153       };
49154     } catch (Dali::DaliException e) {
49155       {
49156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49157       };
49158     } catch (...) {
49159       {
49160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49161       };
49162     }
49163   }
49164
49165   jresult = (void *)result;
49166   return jresult;
49167 }
49168
49169
49170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49171   void * jresult ;
49172   std::string arg1 ;
49173   Dali::Property::Value arg2 ;
49174   Dali::Property::Value *argp2 ;
49175   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49176
49177   if (!jarg1) {
49178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49179     return 0;
49180   }
49181   (&arg1)->assign(jarg1);
49182   argp2 = (Dali::Property::Value *)jarg2;
49183   if (!argp2) {
49184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49185     return 0;
49186   }
49187   arg2 = *argp2;
49188   {
49189     try {
49190       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49191     } catch (std::out_of_range& e) {
49192       {
49193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49194       };
49195     } catch (std::exception& e) {
49196       {
49197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49198       };
49199     } catch (Dali::DaliException e) {
49200       {
49201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49202       };
49203     } catch (...) {
49204       {
49205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49206       };
49207     }
49208   }
49209
49210   jresult = (void *)result;
49211   return jresult;
49212 }
49213
49214
49215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49216   void * jresult ;
49217   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49218   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49219
49220   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49221   if (!arg1) {
49222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49223     return 0;
49224   }
49225   {
49226     try {
49227       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);
49228     } catch (std::out_of_range& e) {
49229       {
49230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49231       };
49232     } catch (std::exception& e) {
49233       {
49234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49235       };
49236     } catch (Dali::DaliException e) {
49237       {
49238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49239       };
49240     } catch (...) {
49241       {
49242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49243       };
49244     }
49245   }
49246
49247   jresult = (void *)result;
49248   return jresult;
49249 }
49250
49251
49252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49253   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49254   std::string *arg2 = 0 ;
49255
49256   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49257   if (!jarg2) {
49258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49259     return ;
49260   }
49261   std::string arg2_str(jarg2);
49262   arg2 = &arg2_str;
49263   if (arg1) (arg1)->first = *arg2;
49264
49265   //argout typemap for const std::string&
49266
49267 }
49268
49269
49270 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49271   char * jresult ;
49272   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49273   std::string *result = 0 ;
49274
49275   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49276   result = (std::string *) & ((arg1)->first);
49277   jresult = SWIG_csharp_string_callback(result->c_str());
49278   return jresult;
49279 }
49280
49281
49282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49283   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49284   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49285
49286   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49287   arg2 = (Dali::Property::Value *)jarg2;
49288   if (arg1) (arg1)->second = *arg2;
49289 }
49290
49291
49292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49293   void * jresult ;
49294   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49295   Dali::Property::Value *result = 0 ;
49296
49297   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49298   result = (Dali::Property::Value *)& ((arg1)->second);
49299   jresult = (void *)result;
49300   return jresult;
49301 }
49302
49303
49304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49305   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49306
49307   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49308   {
49309     try {
49310       delete arg1;
49311     } catch (std::out_of_range& e) {
49312       {
49313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49314       };
49315     } catch (std::exception& e) {
49316       {
49317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49318       };
49319     } catch (Dali::DaliException e) {
49320       {
49321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49322       };
49323     } catch (...) {
49324       {
49325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49326       };
49327     }
49328   }
49329
49330 }
49331
49332
49333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49334   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49335
49336   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49337   {
49338     try {
49339       (arg1)->clear();
49340     } catch (std::out_of_range& e) {
49341       {
49342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49343       };
49344     } catch (std::exception& e) {
49345       {
49346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49347       };
49348     } catch (Dali::DaliException e) {
49349       {
49350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49351       };
49352     } catch (...) {
49353       {
49354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49355       };
49356     }
49357   }
49358
49359 }
49360
49361
49362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49363   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49364   Dali::TouchPoint *arg2 = 0 ;
49365
49366   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49367   arg2 = (Dali::TouchPoint *)jarg2;
49368   if (!arg2) {
49369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49370     return ;
49371   }
49372   {
49373     try {
49374       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49375     } catch (std::out_of_range& e) {
49376       {
49377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49378       };
49379     } catch (std::exception& e) {
49380       {
49381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49382       };
49383     } catch (Dali::DaliException e) {
49384       {
49385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49386       };
49387     } catch (...) {
49388       {
49389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49390       };
49391     }
49392   }
49393
49394 }
49395
49396
49397 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49398   unsigned long jresult ;
49399   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49400   std::vector< Dali::TouchPoint >::size_type result;
49401
49402   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49403   {
49404     try {
49405       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49406     } catch (std::out_of_range& e) {
49407       {
49408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49409       };
49410     } catch (std::exception& e) {
49411       {
49412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49413       };
49414     } catch (Dali::DaliException e) {
49415       {
49416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49417       };
49418     } catch (...) {
49419       {
49420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49421       };
49422     }
49423   }
49424
49425   jresult = (unsigned long)result;
49426   return jresult;
49427 }
49428
49429
49430 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49431   unsigned long jresult ;
49432   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49433   std::vector< Dali::TouchPoint >::size_type result;
49434
49435   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49436   {
49437     try {
49438       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49439     } catch (std::out_of_range& e) {
49440       {
49441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49442       };
49443     } catch (std::exception& e) {
49444       {
49445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49446       };
49447     } catch (Dali::DaliException e) {
49448       {
49449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49450       };
49451     } catch (...) {
49452       {
49453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49454       };
49455     }
49456   }
49457
49458   jresult = (unsigned long)result;
49459   return jresult;
49460 }
49461
49462
49463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49464   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49465   std::vector< Dali::TouchPoint >::size_type arg2 ;
49466
49467   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49468   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49469   {
49470     try {
49471       (arg1)->reserve(arg2);
49472     } catch (std::out_of_range& e) {
49473       {
49474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49475       };
49476     } catch (std::exception& e) {
49477       {
49478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49479       };
49480     } catch (Dali::DaliException e) {
49481       {
49482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49483       };
49484     } catch (...) {
49485       {
49486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49487       };
49488     }
49489   }
49490
49491 }
49492
49493
49494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49495   void * jresult ;
49496   std::vector< Dali::TouchPoint > *result = 0 ;
49497
49498   {
49499     try {
49500       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49501     } catch (std::out_of_range& e) {
49502       {
49503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49504       };
49505     } catch (std::exception& e) {
49506       {
49507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49508       };
49509     } catch (Dali::DaliException e) {
49510       {
49511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49512       };
49513     } catch (...) {
49514       {
49515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49516       };
49517     }
49518   }
49519
49520   jresult = (void *)result;
49521   return jresult;
49522 }
49523
49524
49525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49526   void * jresult ;
49527   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49528   std::vector< Dali::TouchPoint > *result = 0 ;
49529
49530   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49531   if (!arg1) {
49532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49533     return 0;
49534   }
49535   {
49536     try {
49537       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49538     } catch (std::out_of_range& e) {
49539       {
49540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49541       };
49542     } catch (std::exception& e) {
49543       {
49544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49545       };
49546     } catch (Dali::DaliException e) {
49547       {
49548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49549       };
49550     } catch (...) {
49551       {
49552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49553       };
49554     }
49555   }
49556
49557   jresult = (void *)result;
49558   return jresult;
49559 }
49560
49561
49562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49563   void * jresult ;
49564   int arg1 ;
49565   std::vector< Dali::TouchPoint > *result = 0 ;
49566
49567   arg1 = (int)jarg1;
49568   {
49569     try {
49570       try {
49571         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49572       }
49573       catch(std::out_of_range &_e) {
49574         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49575         return 0;
49576       }
49577
49578     } catch (std::out_of_range& e) {
49579       {
49580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49581       };
49582     } catch (std::exception& e) {
49583       {
49584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49585       };
49586     } catch (Dali::DaliException e) {
49587       {
49588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49589       };
49590     } catch (...) {
49591       {
49592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49593       };
49594     }
49595   }
49596
49597   jresult = (void *)result;
49598   return jresult;
49599 }
49600
49601
49602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49603   void * jresult ;
49604   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49605   int arg2 ;
49606   SwigValueWrapper< Dali::TouchPoint > result;
49607
49608   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49609   arg2 = (int)jarg2;
49610   {
49611     try {
49612       try {
49613         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49614       }
49615       catch(std::out_of_range &_e) {
49616         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49617         return 0;
49618       }
49619
49620     } catch (std::out_of_range& e) {
49621       {
49622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49623       };
49624     } catch (std::exception& e) {
49625       {
49626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49627       };
49628     } catch (Dali::DaliException e) {
49629       {
49630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49631       };
49632     } catch (...) {
49633       {
49634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49635       };
49636     }
49637   }
49638
49639   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49640   return jresult;
49641 }
49642
49643
49644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49645   void * jresult ;
49646   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49647   int arg2 ;
49648   Dali::TouchPoint *result = 0 ;
49649
49650   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49651   arg2 = (int)jarg2;
49652   {
49653     try {
49654       try {
49655         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49656       }
49657       catch(std::out_of_range &_e) {
49658         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49659         return 0;
49660       }
49661
49662     } catch (std::out_of_range& e) {
49663       {
49664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49665       };
49666     } catch (std::exception& e) {
49667       {
49668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49669       };
49670     } catch (Dali::DaliException e) {
49671       {
49672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49673       };
49674     } catch (...) {
49675       {
49676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49677       };
49678     }
49679   }
49680
49681   jresult = (void *)result;
49682   return jresult;
49683 }
49684
49685
49686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49687   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49688   int arg2 ;
49689   Dali::TouchPoint *arg3 = 0 ;
49690
49691   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49692   arg2 = (int)jarg2;
49693   arg3 = (Dali::TouchPoint *)jarg3;
49694   if (!arg3) {
49695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49696     return ;
49697   }
49698   {
49699     try {
49700       try {
49701         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49702       }
49703       catch(std::out_of_range &_e) {
49704         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49705         return ;
49706       }
49707
49708     } catch (std::out_of_range& e) {
49709       {
49710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49711       };
49712     } catch (std::exception& e) {
49713       {
49714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49715       };
49716     } catch (Dali::DaliException e) {
49717       {
49718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49719       };
49720     } catch (...) {
49721       {
49722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49723       };
49724     }
49725   }
49726
49727 }
49728
49729
49730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49731   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49732   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49733
49734   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49735   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49736   if (!arg2) {
49737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49738     return ;
49739   }
49740   {
49741     try {
49742       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49743     } catch (std::out_of_range& e) {
49744       {
49745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49746       };
49747     } catch (std::exception& e) {
49748       {
49749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49750       };
49751     } catch (Dali::DaliException e) {
49752       {
49753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49754       };
49755     } catch (...) {
49756       {
49757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49758       };
49759     }
49760   }
49761
49762 }
49763
49764
49765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49766   void * jresult ;
49767   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49768   int arg2 ;
49769   int arg3 ;
49770   std::vector< Dali::TouchPoint > *result = 0 ;
49771
49772   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49773   arg2 = (int)jarg2;
49774   arg3 = (int)jarg3;
49775   {
49776     try {
49777       try {
49778         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49779       }
49780       catch(std::out_of_range &_e) {
49781         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49782         return 0;
49783       }
49784       catch(std::invalid_argument &_e) {
49785         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49786         return 0;
49787       }
49788
49789     } catch (std::out_of_range& e) {
49790       {
49791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49792       };
49793     } catch (std::exception& e) {
49794       {
49795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49796       };
49797     } catch (Dali::DaliException e) {
49798       {
49799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49800       };
49801     } catch (...) {
49802       {
49803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49804       };
49805     }
49806   }
49807
49808   jresult = (void *)result;
49809   return jresult;
49810 }
49811
49812
49813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49814   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49815   int arg2 ;
49816   Dali::TouchPoint *arg3 = 0 ;
49817
49818   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49819   arg2 = (int)jarg2;
49820   arg3 = (Dali::TouchPoint *)jarg3;
49821   if (!arg3) {
49822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49823     return ;
49824   }
49825   {
49826     try {
49827       try {
49828         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49829       }
49830       catch(std::out_of_range &_e) {
49831         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49832         return ;
49833       }
49834
49835     } catch (std::out_of_range& e) {
49836       {
49837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49838       };
49839     } catch (std::exception& e) {
49840       {
49841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49842       };
49843     } catch (Dali::DaliException e) {
49844       {
49845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49846       };
49847     } catch (...) {
49848       {
49849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49850       };
49851     }
49852   }
49853
49854 }
49855
49856
49857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49858   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49859   int arg2 ;
49860   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49861
49862   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49863   arg2 = (int)jarg2;
49864   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49865   if (!arg3) {
49866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49867     return ;
49868   }
49869   {
49870     try {
49871       try {
49872         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49873       }
49874       catch(std::out_of_range &_e) {
49875         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49876         return ;
49877       }
49878
49879     } catch (std::out_of_range& e) {
49880       {
49881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49882       };
49883     } catch (std::exception& e) {
49884       {
49885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49886       };
49887     } catch (Dali::DaliException e) {
49888       {
49889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49890       };
49891     } catch (...) {
49892       {
49893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49894       };
49895     }
49896   }
49897
49898 }
49899
49900
49901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49902   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49903   int arg2 ;
49904
49905   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49906   arg2 = (int)jarg2;
49907   {
49908     try {
49909       try {
49910         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49911       }
49912       catch(std::out_of_range &_e) {
49913         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49914         return ;
49915       }
49916
49917     } catch (std::out_of_range& e) {
49918       {
49919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49920       };
49921     } catch (std::exception& e) {
49922       {
49923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49924       };
49925     } catch (Dali::DaliException e) {
49926       {
49927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49928       };
49929     } catch (...) {
49930       {
49931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49932       };
49933     }
49934   }
49935
49936 }
49937
49938
49939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49940   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49941   int arg2 ;
49942   int arg3 ;
49943
49944   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49945   arg2 = (int)jarg2;
49946   arg3 = (int)jarg3;
49947   {
49948     try {
49949       try {
49950         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49951       }
49952       catch(std::out_of_range &_e) {
49953         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49954         return ;
49955       }
49956       catch(std::invalid_argument &_e) {
49957         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49958         return ;
49959       }
49960
49961     } catch (std::out_of_range& e) {
49962       {
49963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49964       };
49965     } catch (std::exception& e) {
49966       {
49967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49968       };
49969     } catch (Dali::DaliException e) {
49970       {
49971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49972       };
49973     } catch (...) {
49974       {
49975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49976       };
49977     }
49978   }
49979
49980 }
49981
49982
49983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49984   void * jresult ;
49985   Dali::TouchPoint *arg1 = 0 ;
49986   int arg2 ;
49987   std::vector< Dali::TouchPoint > *result = 0 ;
49988
49989   arg1 = (Dali::TouchPoint *)jarg1;
49990   if (!arg1) {
49991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49992     return 0;
49993   }
49994   arg2 = (int)jarg2;
49995   {
49996     try {
49997       try {
49998         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49999       }
50000       catch(std::out_of_range &_e) {
50001         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
50002         return 0;
50003       }
50004
50005     } catch (std::out_of_range& e) {
50006       {
50007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50008       };
50009     } catch (std::exception& e) {
50010       {
50011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50012       };
50013     } catch (Dali::DaliException e) {
50014       {
50015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50016       };
50017     } catch (...) {
50018       {
50019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50020       };
50021     }
50022   }
50023
50024   jresult = (void *)result;
50025   return jresult;
50026 }
50027
50028
50029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
50030   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50031
50032   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50033   {
50034     try {
50035       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
50036     } catch (std::out_of_range& e) {
50037       {
50038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50039       };
50040     } catch (std::exception& e) {
50041       {
50042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50043       };
50044     } catch (Dali::DaliException e) {
50045       {
50046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50047       };
50048     } catch (...) {
50049       {
50050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50051       };
50052     }
50053   }
50054
50055 }
50056
50057
50058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
50059   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50060   int arg2 ;
50061   int arg3 ;
50062
50063   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50064   arg2 = (int)jarg2;
50065   arg3 = (int)jarg3;
50066   {
50067     try {
50068       try {
50069         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
50070       }
50071       catch(std::out_of_range &_e) {
50072         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
50073         return ;
50074       }
50075       catch(std::invalid_argument &_e) {
50076         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
50077         return ;
50078       }
50079
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_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
50103   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50104   int arg2 ;
50105   std::vector< Dali::TouchPoint > *arg3 = 0 ;
50106
50107   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50108   arg2 = (int)jarg2;
50109   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
50110   if (!arg3) {
50111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
50112     return ;
50113   }
50114   {
50115     try {
50116       try {
50117         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
50118       }
50119       catch(std::out_of_range &_e) {
50120         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
50121         return ;
50122       }
50123
50124     } catch (std::out_of_range& e) {
50125       {
50126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50127       };
50128     } catch (std::exception& e) {
50129       {
50130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50131       };
50132     } catch (Dali::DaliException e) {
50133       {
50134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50135       };
50136     } catch (...) {
50137       {
50138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50139       };
50140     }
50141   }
50142
50143 }
50144
50145
50146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
50147   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50148
50149   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50150   {
50151     try {
50152       delete arg1;
50153     } catch (std::out_of_range& e) {
50154       {
50155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50156       };
50157     } catch (std::exception& e) {
50158       {
50159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50160       };
50161     } catch (Dali::DaliException e) {
50162       {
50163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50164       };
50165     } catch (...) {
50166       {
50167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50168       };
50169     }
50170   }
50171
50172 }
50173
50174
50175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50176   void * jresult ;
50177   Dali::Rect< int > *result = 0 ;
50178
50179   {
50180     try {
50181       result = (Dali::Rect< int > *)new Dali::Rect< int >();
50182     } catch (std::out_of_range& e) {
50183       {
50184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50185       };
50186     } catch (std::exception& e) {
50187       {
50188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50189       };
50190     } catch (Dali::DaliException e) {
50191       {
50192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50193       };
50194     } catch (...) {
50195       {
50196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50197       };
50198     }
50199   }
50200
50201   jresult = (void *)result;
50202   return jresult;
50203 }
50204
50205
50206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50207   void * jresult ;
50208   int arg1 ;
50209   int arg2 ;
50210   int arg3 ;
50211   int arg4 ;
50212   Dali::Rect< int > *result = 0 ;
50213
50214   arg1 = (int)jarg1;
50215   arg2 = (int)jarg2;
50216   arg3 = (int)jarg3;
50217   arg4 = (int)jarg4;
50218   {
50219     try {
50220       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50221     } catch (std::out_of_range& e) {
50222       {
50223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50224       };
50225     } catch (std::exception& e) {
50226       {
50227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50228       };
50229     } catch (Dali::DaliException e) {
50230       {
50231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50232       };
50233     } catch (...) {
50234       {
50235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50236       };
50237     }
50238   }
50239
50240   jresult = (void *)result;
50241   return jresult;
50242 }
50243
50244
50245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50246   void * jresult ;
50247   Dali::Rect< int > *arg1 = 0 ;
50248   Dali::Rect< int > *result = 0 ;
50249
50250   arg1 = (Dali::Rect< int > *)jarg1;
50251   if (!arg1) {
50252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50253     return 0;
50254   }
50255   {
50256     try {
50257       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
50258     } catch (std::out_of_range& e) {
50259       {
50260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50261       };
50262     } catch (std::exception& e) {
50263       {
50264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50265       };
50266     } catch (Dali::DaliException e) {
50267       {
50268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50269       };
50270     } catch (...) {
50271       {
50272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50273       };
50274     }
50275   }
50276
50277   jresult = (void *)result;
50278   return jresult;
50279 }
50280
50281
50282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
50283   void * jresult ;
50284   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50285   Dali::Rect< int > *arg2 = 0 ;
50286   Dali::Rect< int > *result = 0 ;
50287
50288   arg1 = (Dali::Rect< int > *)jarg1;
50289   arg2 = (Dali::Rect< int > *)jarg2;
50290   if (!arg2) {
50291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50292     return 0;
50293   }
50294   {
50295     try {
50296       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50297     } catch (std::out_of_range& e) {
50298       {
50299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50300       };
50301     } catch (std::exception& e) {
50302       {
50303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50304       };
50305     } catch (Dali::DaliException e) {
50306       {
50307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50308       };
50309     } catch (...) {
50310       {
50311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50312       };
50313     }
50314   }
50315
50316   jresult = (void *)result;
50317   return jresult;
50318 }
50319
50320
50321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50322   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50323   int arg2 ;
50324   int arg3 ;
50325   int arg4 ;
50326   int arg5 ;
50327
50328   arg1 = (Dali::Rect< int > *)jarg1;
50329   arg2 = (int)jarg2;
50330   arg3 = (int)jarg3;
50331   arg4 = (int)jarg4;
50332   arg5 = (int)jarg5;
50333   {
50334     try {
50335       (arg1)->Set(arg2,arg3,arg4,arg5);
50336     } catch (std::out_of_range& e) {
50337       {
50338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50339       };
50340     } catch (std::exception& e) {
50341       {
50342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50343       };
50344     } catch (Dali::DaliException e) {
50345       {
50346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50347       };
50348     } catch (...) {
50349       {
50350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50351       };
50352     }
50353   }
50354
50355 }
50356
50357
50358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50359   unsigned int jresult ;
50360   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50361   bool result;
50362
50363   arg1 = (Dali::Rect< int > *)jarg1;
50364   {
50365     try {
50366       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50367     } catch (std::out_of_range& e) {
50368       {
50369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50370       };
50371     } catch (std::exception& e) {
50372       {
50373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50374       };
50375     } catch (Dali::DaliException e) {
50376       {
50377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50378       };
50379     } catch (...) {
50380       {
50381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50382       };
50383     }
50384   }
50385
50386   jresult = result;
50387   return jresult;
50388 }
50389
50390
50391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50392   int jresult ;
50393   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50394   int result;
50395
50396   arg1 = (Dali::Rect< int > *)jarg1;
50397   {
50398     try {
50399       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50400     } catch (std::out_of_range& e) {
50401       {
50402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50403       };
50404     } catch (std::exception& e) {
50405       {
50406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50407       };
50408     } catch (Dali::DaliException e) {
50409       {
50410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50411       };
50412     } catch (...) {
50413       {
50414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50415       };
50416     }
50417   }
50418
50419   jresult = result;
50420   return jresult;
50421 }
50422
50423
50424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50425   int jresult ;
50426   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50427   int result;
50428
50429   arg1 = (Dali::Rect< int > *)jarg1;
50430   {
50431     try {
50432       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50433     } catch (std::out_of_range& e) {
50434       {
50435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50436       };
50437     } catch (std::exception& e) {
50438       {
50439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50440       };
50441     } catch (Dali::DaliException e) {
50442       {
50443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50444       };
50445     } catch (...) {
50446       {
50447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50448       };
50449     }
50450   }
50451
50452   jresult = result;
50453   return jresult;
50454 }
50455
50456
50457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50458   int jresult ;
50459   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50460   int result;
50461
50462   arg1 = (Dali::Rect< int > *)jarg1;
50463   {
50464     try {
50465       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50466     } catch (std::out_of_range& e) {
50467       {
50468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50469       };
50470     } catch (std::exception& e) {
50471       {
50472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50473       };
50474     } catch (Dali::DaliException e) {
50475       {
50476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50477       };
50478     } catch (...) {
50479       {
50480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50481       };
50482     }
50483   }
50484
50485   jresult = result;
50486   return jresult;
50487 }
50488
50489
50490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50491   int jresult ;
50492   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50493   int result;
50494
50495   arg1 = (Dali::Rect< int > *)jarg1;
50496   {
50497     try {
50498       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50499     } catch (std::out_of_range& e) {
50500       {
50501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50502       };
50503     } catch (std::exception& e) {
50504       {
50505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50506       };
50507     } catch (Dali::DaliException e) {
50508       {
50509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50510       };
50511     } catch (...) {
50512       {
50513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50514       };
50515     }
50516   }
50517
50518   jresult = result;
50519   return jresult;
50520 }
50521
50522
50523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50524   int jresult ;
50525   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50526   int result;
50527
50528   arg1 = (Dali::Rect< int > *)jarg1;
50529   {
50530     try {
50531       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50532     } catch (std::out_of_range& e) {
50533       {
50534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50535       };
50536     } catch (std::exception& e) {
50537       {
50538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50539       };
50540     } catch (Dali::DaliException e) {
50541       {
50542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50543       };
50544     } catch (...) {
50545       {
50546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50547       };
50548     }
50549   }
50550
50551   jresult = result;
50552   return jresult;
50553 }
50554
50555
50556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50557   unsigned int jresult ;
50558   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50559   Dali::Rect< int > *arg2 = 0 ;
50560   bool result;
50561
50562   arg1 = (Dali::Rect< int > *)jarg1;
50563   arg2 = (Dali::Rect< int > *)jarg2;
50564   if (!arg2) {
50565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50566     return 0;
50567   }
50568   {
50569     try {
50570       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50571     } catch (std::out_of_range& e) {
50572       {
50573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50574       };
50575     } catch (std::exception& e) {
50576       {
50577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50578       };
50579     } catch (Dali::DaliException e) {
50580       {
50581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50582       };
50583     } catch (...) {
50584       {
50585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50586       };
50587     }
50588   }
50589
50590   jresult = result;
50591   return jresult;
50592 }
50593
50594
50595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50596   unsigned int jresult ;
50597   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50598   Dali::Rect< int > *arg2 = 0 ;
50599   bool result;
50600
50601   arg1 = (Dali::Rect< int > *)jarg1;
50602   arg2 = (Dali::Rect< int > *)jarg2;
50603   if (!arg2) {
50604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50605     return 0;
50606   }
50607   {
50608     try {
50609       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50610     } catch (std::out_of_range& e) {
50611       {
50612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50613       };
50614     } catch (std::exception& e) {
50615       {
50616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50617       };
50618     } catch (Dali::DaliException e) {
50619       {
50620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50621       };
50622     } catch (...) {
50623       {
50624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50625       };
50626     }
50627   }
50628
50629   jresult = result;
50630   return jresult;
50631 }
50632
50633
50634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50635   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50636   int arg2 ;
50637
50638   arg1 = (Dali::Rect< int > *)jarg1;
50639   arg2 = (int)jarg2;
50640   if (arg1) (arg1)->x = arg2;
50641 }
50642
50643
50644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50645   int jresult ;
50646   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50647   int result;
50648
50649   arg1 = (Dali::Rect< int > *)jarg1;
50650   result = (int) ((arg1)->x);
50651   jresult = result;
50652   return jresult;
50653 }
50654
50655
50656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50657   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50658   int arg2 ;
50659
50660   arg1 = (Dali::Rect< int > *)jarg1;
50661   arg2 = (int)jarg2;
50662   if (arg1) (arg1)->left = arg2;
50663 }
50664
50665
50666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50667   int jresult ;
50668   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50669   int result;
50670
50671   arg1 = (Dali::Rect< int > *)jarg1;
50672   result = (int) ((arg1)->left);
50673   jresult = result;
50674   return jresult;
50675 }
50676
50677
50678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50679   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50680   int arg2 ;
50681
50682   arg1 = (Dali::Rect< int > *)jarg1;
50683   arg2 = (int)jarg2;
50684   if (arg1) (arg1)->y = arg2;
50685 }
50686
50687
50688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50689   int jresult ;
50690   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50691   int result;
50692
50693   arg1 = (Dali::Rect< int > *)jarg1;
50694   result = (int) ((arg1)->y);
50695   jresult = result;
50696   return jresult;
50697 }
50698
50699
50700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50701   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50702   int arg2 ;
50703
50704   arg1 = (Dali::Rect< int > *)jarg1;
50705   arg2 = (int)jarg2;
50706   if (arg1) (arg1)->right = arg2;
50707 }
50708
50709
50710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50711   int jresult ;
50712   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50713   int result;
50714
50715   arg1 = (Dali::Rect< int > *)jarg1;
50716   result = (int) ((arg1)->right);
50717   jresult = result;
50718   return jresult;
50719 }
50720
50721
50722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50723   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50724   int arg2 ;
50725
50726   arg1 = (Dali::Rect< int > *)jarg1;
50727   arg2 = (int)jarg2;
50728   if (arg1) (arg1)->width = arg2;
50729 }
50730
50731
50732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50733   int jresult ;
50734   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50735   int result;
50736
50737   arg1 = (Dali::Rect< int > *)jarg1;
50738   result = (int) ((arg1)->width);
50739   jresult = result;
50740   return jresult;
50741 }
50742
50743
50744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50745   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50746   int arg2 ;
50747
50748   arg1 = (Dali::Rect< int > *)jarg1;
50749   arg2 = (int)jarg2;
50750   if (arg1) (arg1)->bottom = arg2;
50751 }
50752
50753
50754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50755   int jresult ;
50756   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50757   int result;
50758
50759   arg1 = (Dali::Rect< int > *)jarg1;
50760   result = (int) ((arg1)->bottom);
50761   jresult = result;
50762   return jresult;
50763 }
50764
50765
50766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50767   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50768   int arg2 ;
50769
50770   arg1 = (Dali::Rect< int > *)jarg1;
50771   arg2 = (int)jarg2;
50772   if (arg1) (arg1)->height = arg2;
50773 }
50774
50775
50776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50777   int jresult ;
50778   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50779   int result;
50780
50781   arg1 = (Dali::Rect< int > *)jarg1;
50782   result = (int) ((arg1)->height);
50783   jresult = result;
50784   return jresult;
50785 }
50786
50787
50788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50789   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50790   int arg2 ;
50791
50792   arg1 = (Dali::Rect< int > *)jarg1;
50793   arg2 = (int)jarg2;
50794   if (arg1) (arg1)->top = arg2;
50795 }
50796
50797
50798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50799   int jresult ;
50800   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50801   int result;
50802
50803   arg1 = (Dali::Rect< int > *)jarg1;
50804   result = (int) ((arg1)->top);
50805   jresult = result;
50806   return jresult;
50807 }
50808
50809
50810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50811   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50812
50813   arg1 = (Dali::Rect< int > *)jarg1;
50814   {
50815     try {
50816       delete arg1;
50817     } catch (std::out_of_range& e) {
50818       {
50819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50820       };
50821     } catch (std::exception& e) {
50822       {
50823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50824       };
50825     } catch (Dali::DaliException e) {
50826       {
50827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50828       };
50829     } catch (...) {
50830       {
50831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50832       };
50833     }
50834   }
50835
50836 }
50837
50838
50839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50840   void * jresult ;
50841   Dali::Rect< float > *result = 0 ;
50842
50843   {
50844     try {
50845       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50846     } catch (std::out_of_range& e) {
50847       {
50848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50849       };
50850     } catch (std::exception& e) {
50851       {
50852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50853       };
50854     } catch (Dali::DaliException e) {
50855       {
50856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50857       };
50858     } catch (...) {
50859       {
50860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50861       };
50862     }
50863   }
50864
50865   jresult = (void *)result;
50866   return jresult;
50867 }
50868
50869
50870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50871   void * jresult ;
50872   float arg1 ;
50873   float arg2 ;
50874   float arg3 ;
50875   float arg4 ;
50876   Dali::Rect< float > *result = 0 ;
50877
50878   arg1 = (float)jarg1;
50879   arg2 = (float)jarg2;
50880   arg3 = (float)jarg4;
50881   arg4 = (float)jarg3;
50882   {
50883     try {
50884       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50885     } catch (std::out_of_range& e) {
50886       {
50887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50888       };
50889     } catch (std::exception& e) {
50890       {
50891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50892       };
50893     } catch (Dali::DaliException e) {
50894       {
50895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50896       };
50897     } catch (...) {
50898       {
50899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50900       };
50901     }
50902   }
50903
50904   jresult = (void *)result;
50905   return jresult;
50906 }
50907
50908
50909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50910   void * jresult ;
50911   Dali::Rect< float > *arg1 = 0 ;
50912   Dali::Rect< float > *result = 0 ;
50913
50914   arg1 = (Dali::Rect< float > *)jarg1;
50915   if (!arg1) {
50916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50917     return 0;
50918   }
50919   {
50920     try {
50921       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50922     } catch (std::out_of_range& e) {
50923       {
50924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50925       };
50926     } catch (std::exception& e) {
50927       {
50928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50929       };
50930     } catch (Dali::DaliException e) {
50931       {
50932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50933       };
50934     } catch (...) {
50935       {
50936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50937       };
50938     }
50939   }
50940
50941   jresult = (void *)result;
50942   return jresult;
50943 }
50944
50945
50946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50947   void * jresult ;
50948   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50949   Dali::Rect< float > *arg2 = 0 ;
50950   Dali::Rect< float > *result = 0 ;
50951
50952   arg1 = (Dali::Rect< float > *)jarg1;
50953   arg2 = (Dali::Rect< float > *)jarg2;
50954   if (!arg2) {
50955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50956     return 0;
50957   }
50958   {
50959     try {
50960       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50961     } catch (std::out_of_range& e) {
50962       {
50963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50964       };
50965     } catch (std::exception& e) {
50966       {
50967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50968       };
50969     } catch (Dali::DaliException e) {
50970       {
50971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50972       };
50973     } catch (...) {
50974       {
50975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50976       };
50977     }
50978   }
50979
50980   jresult = (void *)result;
50981   return jresult;
50982 }
50983
50984
50985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50986   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50987   float arg2 ;
50988   float arg3 ;
50989   float arg4 ;
50990   float arg5 ;
50991
50992   arg1 = (Dali::Rect< float > *)jarg1;
50993   arg2 = (float)jarg2;
50994   arg3 = (float)jarg3;
50995   arg4 = (float)jarg5;
50996   arg5 = (float)jarg4;
50997   {
50998     try {
50999       (arg1)->Set(arg2,arg3,arg4,arg5);
51000     } catch (std::out_of_range& e) {
51001       {
51002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51003       };
51004     } catch (std::exception& e) {
51005       {
51006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51007       };
51008     } catch (Dali::DaliException e) {
51009       {
51010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51011       };
51012     } catch (...) {
51013       {
51014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51015       };
51016     }
51017   }
51018
51019 }
51020
51021
51022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
51023   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51024   float arg2 ;
51025
51026   arg1 = (Dali::Rect< float > *)jarg1;
51027   arg2 = (float)jarg2;
51028   if (arg1) (arg1)->left = arg2;
51029 }
51030
51031
51032 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
51033   float jresult ;
51034   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51035   float result;
51036
51037   arg1 = (Dali::Rect< float > *)jarg1;
51038   result = (float) ((arg1)->left);
51039   jresult = result;
51040   return jresult;
51041 }
51042
51043
51044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
51045   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51046   float arg2 ;
51047
51048   arg1 = (Dali::Rect< float > *)jarg1;
51049   arg2 = (float)jarg2;
51050   if (arg1) (arg1)->left = arg2;
51051 }
51052
51053
51054 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
51055   float jresult ;
51056   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51057   float result;
51058
51059   arg1 = (Dali::Rect< float > *)jarg1;
51060   result = (float) ((arg1)->left);
51061   jresult = result;
51062   return jresult;
51063 }
51064
51065
51066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
51067   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51068   float arg2 ;
51069
51070   arg1 = (Dali::Rect< float > *)jarg1;
51071   arg2 = (float)jarg2;
51072   if (arg1) (arg1)->right = arg2;
51073 }
51074
51075
51076 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
51077   float jresult ;
51078   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51079   float result;
51080
51081   arg1 = (Dali::Rect< float > *)jarg1;
51082   result = (float) ((arg1)->right);
51083   jresult = result;
51084   return jresult;
51085 }
51086
51087
51088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
51089   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51090   float arg2 ;
51091
51092   arg1 = (Dali::Rect< float > *)jarg1;
51093   arg2 = (float)jarg2;
51094   if (arg1) (arg1)->right = arg2;
51095 }
51096
51097
51098 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
51099   float jresult ;
51100   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51101   float result;
51102
51103   arg1 = (Dali::Rect< float > *)jarg1;
51104   result = (float) ((arg1)->right);
51105   jresult = result;
51106   return jresult;
51107 }
51108
51109
51110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
51111   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51112   float arg2 ;
51113
51114   arg1 = (Dali::Rect< float > *)jarg1;
51115   arg2 = (float)jarg2;
51116   if (arg1) (arg1)->bottom = arg2;
51117 }
51118
51119
51120 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
51121   float jresult ;
51122   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51123   float result;
51124
51125   arg1 = (Dali::Rect< float > *)jarg1;
51126   result = (float) ((arg1)->bottom);
51127   jresult = result;
51128   return jresult;
51129 }
51130
51131
51132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
51133   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51134   float arg2 ;
51135
51136   arg1 = (Dali::Rect< float > *)jarg1;
51137   arg2 = (float)jarg2;
51138   if (arg1) (arg1)->top = arg2;
51139 }
51140
51141
51142 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
51143   float jresult ;
51144   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51145   float result;
51146
51147   arg1 = (Dali::Rect< float > *)jarg1;
51148   result = (float) ((arg1)->top);
51149   jresult = result;
51150   return jresult;
51151 }
51152
51153
51154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
51155   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51156
51157   arg1 = (Dali::Rect< float > *)jarg1;
51158   {
51159     try {
51160       delete arg1;
51161     } catch (std::out_of_range& e) {
51162       {
51163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51164       };
51165     } catch (std::exception& e) {
51166       {
51167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51168       };
51169     } catch (Dali::DaliException e) {
51170       {
51171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51172       };
51173     } catch (...) {
51174       {
51175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51176       };
51177     }
51178   }
51179
51180 }
51181
51182
51183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51184   int jresult ;
51185   int result;
51186
51187   result = (int)Dali::Vector< int >::BaseType;
51188   jresult = (int)result;
51189   return jresult;
51190 }
51191
51192
51193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51194   void * jresult ;
51195   Dali::Vector< int > *result = 0 ;
51196
51197   {
51198     try {
51199       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51200     } catch (std::out_of_range& e) {
51201       {
51202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51203       };
51204     } catch (std::exception& e) {
51205       {
51206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51207       };
51208     } catch (Dali::DaliException e) {
51209       {
51210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51211       };
51212     } catch (...) {
51213       {
51214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51215       };
51216     }
51217   }
51218
51219   jresult = (void *)result;
51220   return jresult;
51221 }
51222
51223
51224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51225   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51226
51227   arg1 = (Dali::Vector< int > *)jarg1;
51228   {
51229     try {
51230       delete arg1;
51231     } catch (std::out_of_range& e) {
51232       {
51233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51234       };
51235     } catch (std::exception& e) {
51236       {
51237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51238       };
51239     } catch (Dali::DaliException e) {
51240       {
51241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51242       };
51243     } catch (...) {
51244       {
51245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51246       };
51247     }
51248   }
51249
51250 }
51251
51252
51253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51254   void * jresult ;
51255   Dali::Vector< int > *arg1 = 0 ;
51256   Dali::Vector< int > *result = 0 ;
51257
51258   arg1 = (Dali::Vector< int > *)jarg1;
51259   if (!arg1) {
51260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51261     return 0;
51262   }
51263   {
51264     try {
51265       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51266     } catch (std::out_of_range& e) {
51267       {
51268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51269       };
51270     } catch (std::exception& e) {
51271       {
51272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51273       };
51274     } catch (Dali::DaliException e) {
51275       {
51276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51277       };
51278     } catch (...) {
51279       {
51280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51281       };
51282     }
51283   }
51284
51285   jresult = (void *)result;
51286   return jresult;
51287 }
51288
51289
51290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51291   void * jresult ;
51292   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51293   Dali::Vector< int > *arg2 = 0 ;
51294   Dali::Vector< int > *result = 0 ;
51295
51296   arg1 = (Dali::Vector< int > *)jarg1;
51297   arg2 = (Dali::Vector< int > *)jarg2;
51298   if (!arg2) {
51299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51300     return 0;
51301   }
51302   {
51303     try {
51304       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51305     } catch (std::out_of_range& e) {
51306       {
51307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51308       };
51309     } catch (std::exception& e) {
51310       {
51311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51312       };
51313     } catch (Dali::DaliException e) {
51314       {
51315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51316       };
51317     } catch (...) {
51318       {
51319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51320       };
51321     }
51322   }
51323
51324   jresult = (void *)result;
51325   return jresult;
51326 }
51327
51328
51329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51330   void * jresult ;
51331   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51332   Dali::Vector< int >::Iterator result;
51333
51334   arg1 = (Dali::Vector< int > *)jarg1;
51335   {
51336     try {
51337       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51338     } catch (std::out_of_range& e) {
51339       {
51340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51341       };
51342     } catch (std::exception& e) {
51343       {
51344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51345       };
51346     } catch (Dali::DaliException e) {
51347       {
51348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51349       };
51350     } catch (...) {
51351       {
51352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51353       };
51354     }
51355   }
51356
51357   jresult = (void *)result;
51358   return jresult;
51359 }
51360
51361
51362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51363   void * jresult ;
51364   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51365   Dali::Vector< int >::Iterator result;
51366
51367   arg1 = (Dali::Vector< int > *)jarg1;
51368   {
51369     try {
51370       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51371     } catch (std::out_of_range& e) {
51372       {
51373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51374       };
51375     } catch (std::exception& e) {
51376       {
51377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51378       };
51379     } catch (Dali::DaliException e) {
51380       {
51381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51382       };
51383     } catch (...) {
51384       {
51385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51386       };
51387     }
51388   }
51389
51390   jresult = (void *)result;
51391   return jresult;
51392 }
51393
51394
51395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51396   void * jresult ;
51397   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51398   Dali::Vector< int >::SizeType arg2 ;
51399   Dali::Vector< int >::ItemType *result = 0 ;
51400
51401   arg1 = (Dali::Vector< int > *)jarg1;
51402   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51403   {
51404     try {
51405       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51406     } catch (std::out_of_range& e) {
51407       {
51408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51409       };
51410     } catch (std::exception& e) {
51411       {
51412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51413       };
51414     } catch (Dali::DaliException e) {
51415       {
51416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51417       };
51418     } catch (...) {
51419       {
51420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51421       };
51422     }
51423   }
51424
51425   jresult = (void *)result;
51426   return jresult;
51427 }
51428
51429
51430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51431   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51432   Dali::Vector< int >::ItemType *arg2 = 0 ;
51433   Dali::Vector< int >::ItemType temp2 ;
51434
51435   arg1 = (Dali::Vector< int > *)jarg1;
51436   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51437   arg2 = &temp2;
51438   {
51439     try {
51440       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51441     } catch (std::out_of_range& e) {
51442       {
51443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51444       };
51445     } catch (std::exception& e) {
51446       {
51447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51448       };
51449     } catch (Dali::DaliException e) {
51450       {
51451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51452       };
51453     } catch (...) {
51454       {
51455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51456       };
51457     }
51458   }
51459
51460 }
51461
51462
51463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51464   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51465   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51466   Dali::Vector< int >::ItemType *arg3 = 0 ;
51467   Dali::Vector< int >::ItemType temp3 ;
51468
51469   arg1 = (Dali::Vector< int > *)jarg1;
51470   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51471   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51472   arg3 = &temp3;
51473   {
51474     try {
51475       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51476     } catch (std::out_of_range& e) {
51477       {
51478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51479       };
51480     } catch (std::exception& e) {
51481       {
51482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51483       };
51484     } catch (Dali::DaliException e) {
51485       {
51486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51487       };
51488     } catch (...) {
51489       {
51490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51491       };
51492     }
51493   }
51494
51495 }
51496
51497
51498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51499   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51500   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51501   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51502   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51503
51504   arg1 = (Dali::Vector< int > *)jarg1;
51505   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51506   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51507   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51508   {
51509     try {
51510       (arg1)->Insert(arg2,arg3,arg4);
51511     } catch (std::out_of_range& e) {
51512       {
51513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51514       };
51515     } catch (std::exception& e) {
51516       {
51517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51518       };
51519     } catch (Dali::DaliException e) {
51520       {
51521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51522       };
51523     } catch (...) {
51524       {
51525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51526       };
51527     }
51528   }
51529
51530 }
51531
51532
51533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51534   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51535   Dali::Vector< int >::SizeType arg2 ;
51536
51537   arg1 = (Dali::Vector< int > *)jarg1;
51538   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51539   {
51540     try {
51541       (arg1)->Reserve(arg2);
51542     } catch (std::out_of_range& e) {
51543       {
51544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51545       };
51546     } catch (std::exception& e) {
51547       {
51548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51549       };
51550     } catch (Dali::DaliException e) {
51551       {
51552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51553       };
51554     } catch (...) {
51555       {
51556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51557       };
51558     }
51559   }
51560
51561 }
51562
51563
51564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51565   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51566   Dali::Vector< int >::SizeType arg2 ;
51567
51568   arg1 = (Dali::Vector< int > *)jarg1;
51569   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51570   {
51571     try {
51572       (arg1)->Resize(arg2);
51573     } catch (std::out_of_range& e) {
51574       {
51575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51576       };
51577     } catch (std::exception& e) {
51578       {
51579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51580       };
51581     } catch (Dali::DaliException e) {
51582       {
51583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51584       };
51585     } catch (...) {
51586       {
51587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51588       };
51589     }
51590   }
51591
51592 }
51593
51594
51595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51596   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51597   Dali::Vector< int >::SizeType arg2 ;
51598   Dali::Vector< int >::ItemType *arg3 = 0 ;
51599   Dali::Vector< int >::ItemType temp3 ;
51600
51601   arg1 = (Dali::Vector< int > *)jarg1;
51602   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51603   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51604   arg3 = &temp3;
51605   {
51606     try {
51607       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51608     } catch (std::out_of_range& e) {
51609       {
51610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51611       };
51612     } catch (std::exception& e) {
51613       {
51614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51615       };
51616     } catch (Dali::DaliException e) {
51617       {
51618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51619       };
51620     } catch (...) {
51621       {
51622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51623       };
51624     }
51625   }
51626
51627 }
51628
51629
51630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51631   void * jresult ;
51632   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51633   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51634   Dali::Vector< int >::Iterator result;
51635
51636   arg1 = (Dali::Vector< int > *)jarg1;
51637   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51638   {
51639     try {
51640       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51641     } catch (std::out_of_range& e) {
51642       {
51643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51644       };
51645     } catch (std::exception& e) {
51646       {
51647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51648       };
51649     } catch (Dali::DaliException e) {
51650       {
51651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51652       };
51653     } catch (...) {
51654       {
51655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51656       };
51657     }
51658   }
51659
51660   jresult = (void *)result;
51661   return jresult;
51662 }
51663
51664
51665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51666   void * jresult ;
51667   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51668   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51669   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51670   Dali::Vector< int >::Iterator result;
51671
51672   arg1 = (Dali::Vector< int > *)jarg1;
51673   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51674   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51675   {
51676     try {
51677       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51678     } catch (std::out_of_range& e) {
51679       {
51680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51681       };
51682     } catch (std::exception& e) {
51683       {
51684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51685       };
51686     } catch (Dali::DaliException e) {
51687       {
51688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51689       };
51690     } catch (...) {
51691       {
51692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51693       };
51694     }
51695   }
51696
51697   jresult = (void *)result;
51698   return jresult;
51699 }
51700
51701
51702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51703   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51704   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51705
51706   arg1 = (Dali::Vector< int > *)jarg1;
51707   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51708   {
51709     try {
51710       (arg1)->Remove(arg2);
51711     } catch (std::out_of_range& e) {
51712       {
51713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51714       };
51715     } catch (std::exception& e) {
51716       {
51717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51718       };
51719     } catch (Dali::DaliException e) {
51720       {
51721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51722       };
51723     } catch (...) {
51724       {
51725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51726       };
51727     }
51728   }
51729
51730 }
51731
51732
51733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51734   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51735   Dali::Vector< int > *arg2 = 0 ;
51736
51737   arg1 = (Dali::Vector< int > *)jarg1;
51738   arg2 = (Dali::Vector< int > *)jarg2;
51739   if (!arg2) {
51740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51741     return ;
51742   }
51743   {
51744     try {
51745       (arg1)->Swap(*arg2);
51746     } catch (std::out_of_range& e) {
51747       {
51748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51749       };
51750     } catch (std::exception& e) {
51751       {
51752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51753       };
51754     } catch (Dali::DaliException e) {
51755       {
51756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51757       };
51758     } catch (...) {
51759       {
51760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51761       };
51762     }
51763   }
51764
51765 }
51766
51767
51768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51769   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51770
51771   arg1 = (Dali::Vector< int > *)jarg1;
51772   {
51773     try {
51774       (arg1)->Clear();
51775     } catch (std::out_of_range& e) {
51776       {
51777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51778       };
51779     } catch (std::exception& e) {
51780       {
51781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51782       };
51783     } catch (Dali::DaliException e) {
51784       {
51785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51786       };
51787     } catch (...) {
51788       {
51789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51790       };
51791     }
51792   }
51793
51794 }
51795
51796
51797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51798   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51799
51800   arg1 = (Dali::Vector< int > *)jarg1;
51801   {
51802     try {
51803       (arg1)->Release();
51804     } catch (std::out_of_range& e) {
51805       {
51806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51807       };
51808     } catch (std::exception& e) {
51809       {
51810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51811       };
51812     } catch (Dali::DaliException e) {
51813       {
51814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51815       };
51816     } catch (...) {
51817       {
51818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51819       };
51820     }
51821   }
51822
51823 }
51824
51825
51826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51827   int jresult ;
51828   int result;
51829
51830   result = (int)Dali::Vector< float >::BaseType;
51831   jresult = (int)result;
51832   return jresult;
51833 }
51834
51835
51836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51837   void * jresult ;
51838   Dali::Vector< float > *result = 0 ;
51839
51840   {
51841     try {
51842       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51843     } catch (std::out_of_range& e) {
51844       {
51845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51846       };
51847     } catch (std::exception& e) {
51848       {
51849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51850       };
51851     } catch (Dali::DaliException e) {
51852       {
51853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51854       };
51855     } catch (...) {
51856       {
51857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51858       };
51859     }
51860   }
51861
51862   jresult = (void *)result;
51863   return jresult;
51864 }
51865
51866
51867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51868   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51869
51870   arg1 = (Dali::Vector< float > *)jarg1;
51871   {
51872     try {
51873       delete arg1;
51874     } catch (std::out_of_range& e) {
51875       {
51876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51877       };
51878     } catch (std::exception& e) {
51879       {
51880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51881       };
51882     } catch (Dali::DaliException e) {
51883       {
51884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51885       };
51886     } catch (...) {
51887       {
51888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51889       };
51890     }
51891   }
51892
51893 }
51894
51895
51896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51897   void * jresult ;
51898   Dali::Vector< float > *arg1 = 0 ;
51899   Dali::Vector< float > *result = 0 ;
51900
51901   arg1 = (Dali::Vector< float > *)jarg1;
51902   if (!arg1) {
51903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51904     return 0;
51905   }
51906   {
51907     try {
51908       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51909     } catch (std::out_of_range& e) {
51910       {
51911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51912       };
51913     } catch (std::exception& e) {
51914       {
51915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51916       };
51917     } catch (Dali::DaliException e) {
51918       {
51919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51920       };
51921     } catch (...) {
51922       {
51923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51924       };
51925     }
51926   }
51927
51928   jresult = (void *)result;
51929   return jresult;
51930 }
51931
51932
51933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51934   void * jresult ;
51935   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51936   Dali::Vector< float > *arg2 = 0 ;
51937   Dali::Vector< float > *result = 0 ;
51938
51939   arg1 = (Dali::Vector< float > *)jarg1;
51940   arg2 = (Dali::Vector< float > *)jarg2;
51941   if (!arg2) {
51942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51943     return 0;
51944   }
51945   {
51946     try {
51947       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51948     } catch (std::out_of_range& e) {
51949       {
51950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51951       };
51952     } catch (std::exception& e) {
51953       {
51954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51955       };
51956     } catch (Dali::DaliException e) {
51957       {
51958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51959       };
51960     } catch (...) {
51961       {
51962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51963       };
51964     }
51965   }
51966
51967   jresult = (void *)result;
51968   return jresult;
51969 }
51970
51971
51972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51973   void * jresult ;
51974   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51975   Dali::Vector< float >::Iterator result;
51976
51977   arg1 = (Dali::Vector< float > *)jarg1;
51978   {
51979     try {
51980       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51981     } catch (std::out_of_range& e) {
51982       {
51983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51984       };
51985     } catch (std::exception& e) {
51986       {
51987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51988       };
51989     } catch (Dali::DaliException e) {
51990       {
51991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51992       };
51993     } catch (...) {
51994       {
51995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51996       };
51997     }
51998   }
51999
52000   jresult = (void *)result;
52001   return jresult;
52002 }
52003
52004
52005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
52006   void * jresult ;
52007   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52008   Dali::Vector< float >::Iterator result;
52009
52010   arg1 = (Dali::Vector< float > *)jarg1;
52011   {
52012     try {
52013       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
52014     } catch (std::out_of_range& e) {
52015       {
52016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52017       };
52018     } catch (std::exception& e) {
52019       {
52020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52021       };
52022     } catch (Dali::DaliException e) {
52023       {
52024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52025       };
52026     } catch (...) {
52027       {
52028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52029       };
52030     }
52031   }
52032
52033   jresult = (void *)result;
52034   return jresult;
52035 }
52036
52037
52038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52039   void * jresult ;
52040   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52041   Dali::Vector< float >::SizeType arg2 ;
52042   Dali::Vector< float >::ItemType *result = 0 ;
52043
52044   arg1 = (Dali::Vector< float > *)jarg1;
52045   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52046   {
52047     try {
52048       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
52049     } catch (std::out_of_range& e) {
52050       {
52051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52052       };
52053     } catch (std::exception& e) {
52054       {
52055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52056       };
52057     } catch (Dali::DaliException e) {
52058       {
52059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52060       };
52061     } catch (...) {
52062       {
52063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52064       };
52065     }
52066   }
52067
52068   jresult = (void *)result;
52069   return jresult;
52070 }
52071
52072
52073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
52074   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52075   Dali::Vector< float >::ItemType *arg2 = 0 ;
52076   Dali::Vector< float >::ItemType temp2 ;
52077
52078   arg1 = (Dali::Vector< float > *)jarg1;
52079   temp2 = (Dali::Vector< float >::ItemType)jarg2;
52080   arg2 = &temp2;
52081   {
52082     try {
52083       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
52084     } catch (std::out_of_range& e) {
52085       {
52086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52087       };
52088     } catch (std::exception& e) {
52089       {
52090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52091       };
52092     } catch (Dali::DaliException e) {
52093       {
52094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52095       };
52096     } catch (...) {
52097       {
52098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52099       };
52100     }
52101   }
52102
52103 }
52104
52105
52106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
52107   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52108   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52109   Dali::Vector< float >::ItemType *arg3 = 0 ;
52110   Dali::Vector< float >::ItemType temp3 ;
52111
52112   arg1 = (Dali::Vector< float > *)jarg1;
52113   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52114   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52115   arg3 = &temp3;
52116   {
52117     try {
52118       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52119     } catch (std::out_of_range& e) {
52120       {
52121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52122       };
52123     } catch (std::exception& e) {
52124       {
52125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52126       };
52127     } catch (Dali::DaliException e) {
52128       {
52129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52130       };
52131     } catch (...) {
52132       {
52133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52134       };
52135     }
52136   }
52137
52138 }
52139
52140
52141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
52142   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52143   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52144   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52145   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
52146
52147   arg1 = (Dali::Vector< float > *)jarg1;
52148   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52149   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52150   arg4 = (Dali::Vector< float >::Iterator)jarg4;
52151   {
52152     try {
52153       (arg1)->Insert(arg2,arg3,arg4);
52154     } catch (std::out_of_range& e) {
52155       {
52156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52157       };
52158     } catch (std::exception& e) {
52159       {
52160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52161       };
52162     } catch (Dali::DaliException e) {
52163       {
52164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52165       };
52166     } catch (...) {
52167       {
52168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52169       };
52170     }
52171   }
52172
52173 }
52174
52175
52176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52177   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52178   Dali::Vector< float >::SizeType arg2 ;
52179
52180   arg1 = (Dali::Vector< float > *)jarg1;
52181   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52182   {
52183     try {
52184       (arg1)->Reserve(arg2);
52185     } catch (std::out_of_range& e) {
52186       {
52187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52188       };
52189     } catch (std::exception& e) {
52190       {
52191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52192       };
52193     } catch (Dali::DaliException e) {
52194       {
52195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52196       };
52197     } catch (...) {
52198       {
52199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52200       };
52201     }
52202   }
52203
52204 }
52205
52206 //// ========================= end of part 2 =============================
52207
52208 //// ========================== start part 3 ===============================
52209
52210
52211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52212   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52213   Dali::Vector< float >::SizeType arg2 ;
52214
52215   arg1 = (Dali::Vector< float > *)jarg1;
52216   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52217   {
52218     try {
52219       (arg1)->Resize(arg2);
52220     } catch (std::out_of_range& e) {
52221       {
52222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52223       };
52224     } catch (std::exception& e) {
52225       {
52226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52227       };
52228     } catch (Dali::DaliException e) {
52229       {
52230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52231       };
52232     } catch (...) {
52233       {
52234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52235       };
52236     }
52237   }
52238
52239 }
52240
52241
52242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52243   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52244   Dali::Vector< float >::SizeType arg2 ;
52245   Dali::Vector< float >::ItemType *arg3 = 0 ;
52246   Dali::Vector< float >::ItemType temp3 ;
52247
52248   arg1 = (Dali::Vector< float > *)jarg1;
52249   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52250   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52251   arg3 = &temp3;
52252   {
52253     try {
52254       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52255     } catch (std::out_of_range& e) {
52256       {
52257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52258       };
52259     } catch (std::exception& e) {
52260       {
52261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52262       };
52263     } catch (Dali::DaliException e) {
52264       {
52265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52266       };
52267     } catch (...) {
52268       {
52269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52270       };
52271     }
52272   }
52273
52274 }
52275
52276
52277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52278   void * jresult ;
52279   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52280   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52281   Dali::Vector< float >::Iterator result;
52282
52283   arg1 = (Dali::Vector< float > *)jarg1;
52284   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52285   {
52286     try {
52287       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52288     } catch (std::out_of_range& e) {
52289       {
52290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52291       };
52292     } catch (std::exception& e) {
52293       {
52294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52295       };
52296     } catch (Dali::DaliException e) {
52297       {
52298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52299       };
52300     } catch (...) {
52301       {
52302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52303       };
52304     }
52305   }
52306
52307   jresult = (void *)result;
52308   return jresult;
52309 }
52310
52311
52312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52313   void * jresult ;
52314   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52315   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52316   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52317   Dali::Vector< float >::Iterator result;
52318
52319   arg1 = (Dali::Vector< float > *)jarg1;
52320   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52321   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52322   {
52323     try {
52324       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52325     } catch (std::out_of_range& e) {
52326       {
52327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52328       };
52329     } catch (std::exception& e) {
52330       {
52331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52332       };
52333     } catch (Dali::DaliException e) {
52334       {
52335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52336       };
52337     } catch (...) {
52338       {
52339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52340       };
52341     }
52342   }
52343
52344   jresult = (void *)result;
52345   return jresult;
52346 }
52347
52348
52349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52350   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52351   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52352
52353   arg1 = (Dali::Vector< float > *)jarg1;
52354   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52355   {
52356     try {
52357       (arg1)->Remove(arg2);
52358     } catch (std::out_of_range& e) {
52359       {
52360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52361       };
52362     } catch (std::exception& e) {
52363       {
52364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52365       };
52366     } catch (Dali::DaliException e) {
52367       {
52368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52369       };
52370     } catch (...) {
52371       {
52372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52373       };
52374     }
52375   }
52376
52377 }
52378
52379
52380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52381   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52382   Dali::Vector< float > *arg2 = 0 ;
52383
52384   arg1 = (Dali::Vector< float > *)jarg1;
52385   arg2 = (Dali::Vector< float > *)jarg2;
52386   if (!arg2) {
52387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52388     return ;
52389   }
52390   {
52391     try {
52392       (arg1)->Swap(*arg2);
52393     } catch (std::out_of_range& e) {
52394       {
52395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52396       };
52397     } catch (std::exception& e) {
52398       {
52399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52400       };
52401     } catch (Dali::DaliException e) {
52402       {
52403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52404       };
52405     } catch (...) {
52406       {
52407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52408       };
52409     }
52410   }
52411
52412 }
52413
52414
52415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52416   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52417
52418   arg1 = (Dali::Vector< float > *)jarg1;
52419   {
52420     try {
52421       (arg1)->Clear();
52422     } catch (std::out_of_range& e) {
52423       {
52424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52425       };
52426     } catch (std::exception& e) {
52427       {
52428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52429       };
52430     } catch (Dali::DaliException e) {
52431       {
52432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52433       };
52434     } catch (...) {
52435       {
52436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52437       };
52438     }
52439   }
52440
52441 }
52442
52443
52444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52445   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52446
52447   arg1 = (Dali::Vector< float > *)jarg1;
52448   {
52449     try {
52450       (arg1)->Release();
52451     } catch (std::out_of_range& e) {
52452       {
52453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52454       };
52455     } catch (std::exception& e) {
52456       {
52457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52458       };
52459     } catch (Dali::DaliException e) {
52460       {
52461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52462       };
52463     } catch (...) {
52464       {
52465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52466       };
52467     }
52468   }
52469
52470 }
52471
52472
52473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52474   int jresult ;
52475   int result;
52476
52477   result = (int)Dali::Vector< unsigned char >::BaseType;
52478   jresult = (int)result;
52479   return jresult;
52480 }
52481
52482
52483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52484   void * jresult ;
52485   Dali::Vector< unsigned char > *result = 0 ;
52486
52487   {
52488     try {
52489       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52490     } catch (std::out_of_range& e) {
52491       {
52492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52493       };
52494     } catch (std::exception& e) {
52495       {
52496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52497       };
52498     } catch (Dali::DaliException e) {
52499       {
52500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52501       };
52502     } catch (...) {
52503       {
52504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52505       };
52506     }
52507   }
52508
52509   jresult = (void *)result;
52510   return jresult;
52511 }
52512
52513
52514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52515   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52516
52517   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52518   {
52519     try {
52520       delete arg1;
52521     } catch (std::out_of_range& e) {
52522       {
52523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52524       };
52525     } catch (std::exception& e) {
52526       {
52527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52528       };
52529     } catch (Dali::DaliException e) {
52530       {
52531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52532       };
52533     } catch (...) {
52534       {
52535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52536       };
52537     }
52538   }
52539
52540 }
52541
52542
52543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52544   void * jresult ;
52545   Dali::Vector< unsigned char > *arg1 = 0 ;
52546   Dali::Vector< unsigned char > *result = 0 ;
52547
52548   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52549   if (!arg1) {
52550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52551     return 0;
52552   }
52553   {
52554     try {
52555       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52556     } catch (std::out_of_range& e) {
52557       {
52558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52559       };
52560     } catch (std::exception& e) {
52561       {
52562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52563       };
52564     } catch (Dali::DaliException e) {
52565       {
52566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52567       };
52568     } catch (...) {
52569       {
52570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52571       };
52572     }
52573   }
52574
52575   jresult = (void *)result;
52576   return jresult;
52577 }
52578
52579
52580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52581   void * jresult ;
52582   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52583   Dali::Vector< unsigned char > *arg2 = 0 ;
52584   Dali::Vector< unsigned char > *result = 0 ;
52585
52586   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52587   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52588   if (!arg2) {
52589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52590     return 0;
52591   }
52592   {
52593     try {
52594       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52595     } catch (std::out_of_range& e) {
52596       {
52597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52598       };
52599     } catch (std::exception& e) {
52600       {
52601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52602       };
52603     } catch (Dali::DaliException e) {
52604       {
52605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52606       };
52607     } catch (...) {
52608       {
52609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52610       };
52611     }
52612   }
52613
52614   jresult = (void *)result;
52615   return jresult;
52616 }
52617
52618
52619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52620   void * jresult ;
52621   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52622   Dali::Vector< unsigned char >::Iterator result;
52623
52624   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52625   {
52626     try {
52627       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52628     } catch (std::out_of_range& e) {
52629       {
52630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52631       };
52632     } catch (std::exception& e) {
52633       {
52634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52635       };
52636     } catch (Dali::DaliException e) {
52637       {
52638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52639       };
52640     } catch (...) {
52641       {
52642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52643       };
52644     }
52645   }
52646
52647   jresult = (void *)result;
52648   return jresult;
52649 }
52650
52651
52652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52653   void * jresult ;
52654   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52655   Dali::Vector< unsigned char >::Iterator result;
52656
52657   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52658   {
52659     try {
52660       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52661     } catch (std::out_of_range& e) {
52662       {
52663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52664       };
52665     } catch (std::exception& e) {
52666       {
52667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52668       };
52669     } catch (Dali::DaliException e) {
52670       {
52671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52672       };
52673     } catch (...) {
52674       {
52675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52676       };
52677     }
52678   }
52679
52680   jresult = (void *)result;
52681   return jresult;
52682 }
52683
52684
52685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52686   void * jresult ;
52687   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52688   Dali::Vector< unsigned char >::SizeType arg2 ;
52689   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52690
52691   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52692   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52693   {
52694     try {
52695       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52696     } catch (std::out_of_range& e) {
52697       {
52698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52699       };
52700     } catch (std::exception& e) {
52701       {
52702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52703       };
52704     } catch (Dali::DaliException e) {
52705       {
52706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52707       };
52708     } catch (...) {
52709       {
52710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52711       };
52712     }
52713   }
52714
52715   jresult = (void *)result;
52716   return jresult;
52717 }
52718
52719
52720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52721   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52722   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52723   Dali::Vector< unsigned char >::ItemType temp2 ;
52724
52725   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52726   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52727   arg2 = &temp2;
52728   {
52729     try {
52730       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52731     } catch (std::out_of_range& e) {
52732       {
52733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52734       };
52735     } catch (std::exception& e) {
52736       {
52737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52738       };
52739     } catch (Dali::DaliException e) {
52740       {
52741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52742       };
52743     } catch (...) {
52744       {
52745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52746       };
52747     }
52748   }
52749
52750 }
52751
52752
52753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52754   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52755   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52756   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52757   Dali::Vector< unsigned char >::ItemType temp3 ;
52758
52759   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52760   arg2 = jarg2;
52761   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52762   arg3 = &temp3;
52763   {
52764     try {
52765       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52766     } catch (std::out_of_range& e) {
52767       {
52768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52769       };
52770     } catch (std::exception& e) {
52771       {
52772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52773       };
52774     } catch (Dali::DaliException e) {
52775       {
52776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52777       };
52778     } catch (...) {
52779       {
52780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52781       };
52782     }
52783   }
52784
52785
52786
52787 }
52788
52789
52790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52791   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52792   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52793   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52794   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52795
52796   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52797   arg2 = jarg2;
52798   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52799   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52800   {
52801     try {
52802       (arg1)->Insert(arg2,arg3,arg4);
52803     } catch (std::out_of_range& e) {
52804       {
52805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52806       };
52807     } catch (std::exception& e) {
52808       {
52809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52810       };
52811     } catch (Dali::DaliException e) {
52812       {
52813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52814       };
52815     } catch (...) {
52816       {
52817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52818       };
52819     }
52820   }
52821
52822
52823
52824 }
52825
52826
52827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52828   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52829   Dali::Vector< unsigned char >::SizeType arg2 ;
52830
52831   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52832   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52833   {
52834     try {
52835       (arg1)->Reserve(arg2);
52836     } catch (std::out_of_range& e) {
52837       {
52838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52839       };
52840     } catch (std::exception& e) {
52841       {
52842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52843       };
52844     } catch (Dali::DaliException e) {
52845       {
52846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52847       };
52848     } catch (...) {
52849       {
52850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52851       };
52852     }
52853   }
52854
52855 }
52856
52857
52858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52859   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52860   Dali::Vector< unsigned char >::SizeType arg2 ;
52861
52862   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52863   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52864   {
52865     try {
52866       (arg1)->Resize(arg2);
52867     } catch (std::out_of_range& e) {
52868       {
52869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52870       };
52871     } catch (std::exception& e) {
52872       {
52873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52874       };
52875     } catch (Dali::DaliException e) {
52876       {
52877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52878       };
52879     } catch (...) {
52880       {
52881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52882       };
52883     }
52884   }
52885
52886 }
52887
52888
52889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52890   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52891   Dali::Vector< unsigned char >::SizeType arg2 ;
52892   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52893   Dali::Vector< unsigned char >::ItemType temp3 ;
52894
52895   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52896   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52897   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52898   arg3 = &temp3;
52899   {
52900     try {
52901       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52902     } catch (std::out_of_range& e) {
52903       {
52904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52905       };
52906     } catch (std::exception& e) {
52907       {
52908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52909       };
52910     } catch (Dali::DaliException e) {
52911       {
52912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52913       };
52914     } catch (...) {
52915       {
52916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52917       };
52918     }
52919   }
52920
52921 }
52922
52923
52924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52925   void * jresult ;
52926   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52927   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52928   Dali::Vector< unsigned char >::Iterator result;
52929
52930   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52931   arg2 = jarg2;
52932   {
52933     try {
52934       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52935     } catch (std::out_of_range& e) {
52936       {
52937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52938       };
52939     } catch (std::exception& e) {
52940       {
52941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52942       };
52943     } catch (Dali::DaliException e) {
52944       {
52945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52946       };
52947     } catch (...) {
52948       {
52949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52950       };
52951     }
52952   }
52953
52954   jresult = (void *)result;
52955
52956
52957   return jresult;
52958 }
52959
52960
52961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52962   void * jresult ;
52963   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52964   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52965   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52966   Dali::Vector< unsigned char >::Iterator result;
52967
52968   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52969   arg2 = jarg2;
52970   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52971   {
52972     try {
52973       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52974     } catch (std::out_of_range& e) {
52975       {
52976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52977       };
52978     } catch (std::exception& e) {
52979       {
52980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52981       };
52982     } catch (Dali::DaliException e) {
52983       {
52984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52985       };
52986     } catch (...) {
52987       {
52988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52989       };
52990     }
52991   }
52992
52993   jresult = (void *)result;
52994
52995
52996   return jresult;
52997 }
52998
52999
53000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
53001   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
53002   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
53003
53004   arg1 = (Dali::Vector< unsigned char > *)jarg1;
53005   arg2 = jarg2;
53006   {
53007     try {
53008       (arg1)->Remove(arg2);
53009     } catch (std::out_of_range& e) {
53010       {
53011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53012       };
53013     } catch (std::exception& e) {
53014       {
53015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53016       };
53017     } catch (Dali::DaliException e) {
53018       {
53019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53020       };
53021     } catch (...) {
53022       {
53023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53024       };
53025     }
53026   }
53027
53028
53029
53030 }
53031
53032
53033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
53034   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
53035   Dali::Vector< unsigned char > *arg2 = 0 ;
53036
53037   arg1 = (Dali::Vector< unsigned char > *)jarg1;
53038   arg2 = (Dali::Vector< unsigned char > *)jarg2;
53039   if (!arg2) {
53040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
53041     return ;
53042   }
53043   {
53044     try {
53045       (arg1)->Swap(*arg2);
53046     } catch (std::out_of_range& e) {
53047       {
53048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53049       };
53050     } catch (std::exception& e) {
53051       {
53052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53053       };
53054     } catch (Dali::DaliException e) {
53055       {
53056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53057       };
53058     } catch (...) {
53059       {
53060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53061       };
53062     }
53063   }
53064
53065 }
53066
53067
53068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
53069   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
53070
53071   arg1 = (Dali::Vector< unsigned char > *)jarg1;
53072   {
53073     try {
53074       (arg1)->Clear();
53075     } catch (std::out_of_range& e) {
53076       {
53077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53078       };
53079     } catch (std::exception& e) {
53080       {
53081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53082       };
53083     } catch (Dali::DaliException e) {
53084       {
53085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53086       };
53087     } catch (...) {
53088       {
53089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53090       };
53091     }
53092   }
53093
53094 }
53095
53096
53097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
53098   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
53099
53100   arg1 = (Dali::Vector< unsigned char > *)jarg1;
53101   {
53102     try {
53103       (arg1)->Release();
53104     } catch (std::out_of_range& e) {
53105       {
53106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53107       };
53108     } catch (std::exception& e) {
53109       {
53110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53111       };
53112     } catch (Dali::DaliException e) {
53113       {
53114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53115       };
53116     } catch (...) {
53117       {
53118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53119       };
53120     }
53121   }
53122
53123 }
53124
53125
53126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
53127   int jresult ;
53128   int result;
53129
53130   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
53131   jresult = (int)result;
53132   return jresult;
53133 }
53134
53135
53136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
53137   void * jresult ;
53138   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53139
53140   {
53141     try {
53142       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
53143     } catch (std::out_of_range& e) {
53144       {
53145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53146       };
53147     } catch (std::exception& e) {
53148       {
53149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53150       };
53151     } catch (Dali::DaliException e) {
53152       {
53153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53154       };
53155     } catch (...) {
53156       {
53157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53158       };
53159     }
53160   }
53161
53162   jresult = (void *)result;
53163   return jresult;
53164 }
53165
53166
53167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
53168   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53169
53170   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53171   {
53172     try {
53173       delete arg1;
53174     } catch (std::out_of_range& e) {
53175       {
53176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53177       };
53178     } catch (std::exception& e) {
53179       {
53180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53181       };
53182     } catch (Dali::DaliException e) {
53183       {
53184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53185       };
53186     } catch (...) {
53187       {
53188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53189       };
53190     }
53191   }
53192
53193 }
53194
53195
53196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53197   void * jresult ;
53198   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53199   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53200
53201   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53202   if (!arg1) {
53203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53204     return 0;
53205   }
53206   {
53207     try {
53208       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53209     } catch (std::out_of_range& e) {
53210       {
53211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53212       };
53213     } catch (std::exception& e) {
53214       {
53215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53216       };
53217     } catch (Dali::DaliException e) {
53218       {
53219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53220       };
53221     } catch (...) {
53222       {
53223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53224       };
53225     }
53226   }
53227
53228   jresult = (void *)result;
53229   return jresult;
53230 }
53231
53232
53233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53234   void * jresult ;
53235   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53236   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53237   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53238
53239   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53240   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53241   if (!arg2) {
53242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53243     return 0;
53244   }
53245   {
53246     try {
53247       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
53248     } catch (std::out_of_range& e) {
53249       {
53250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53251       };
53252     } catch (std::exception& e) {
53253       {
53254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53255       };
53256     } catch (Dali::DaliException e) {
53257       {
53258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53259       };
53260     } catch (...) {
53261       {
53262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53263       };
53264     }
53265   }
53266
53267   jresult = (void *)result;
53268   return jresult;
53269 }
53270
53271
53272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53273   void * jresult ;
53274   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53275   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53276
53277   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53278   {
53279     try {
53280       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53281     } catch (std::out_of_range& e) {
53282       {
53283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53284       };
53285     } catch (std::exception& e) {
53286       {
53287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53288       };
53289     } catch (Dali::DaliException e) {
53290       {
53291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53292       };
53293     } catch (...) {
53294       {
53295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53296       };
53297     }
53298   }
53299
53300   jresult = (void *)result;
53301   return jresult;
53302 }
53303
53304
53305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53306   void * jresult ;
53307   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53308   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53309
53310   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53311   {
53312     try {
53313       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53314     } catch (std::out_of_range& e) {
53315       {
53316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53317       };
53318     } catch (std::exception& e) {
53319       {
53320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53321       };
53322     } catch (Dali::DaliException e) {
53323       {
53324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53325       };
53326     } catch (...) {
53327       {
53328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53329       };
53330     }
53331   }
53332
53333   jresult = (void *)result;
53334   return jresult;
53335 }
53336
53337
53338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53339   void * jresult ;
53340   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53341   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53342   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53343
53344   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53345   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53346   {
53347     try {
53348       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53349     } catch (std::out_of_range& e) {
53350       {
53351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53352       };
53353     } catch (std::exception& e) {
53354       {
53355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53356       };
53357     } catch (Dali::DaliException e) {
53358       {
53359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53360       };
53361     } catch (...) {
53362       {
53363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53364       };
53365     }
53366   }
53367
53368   jresult = (void *)result;
53369   return jresult;
53370 }
53371
53372
53373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53374   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53375   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53376
53377   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53378   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53379   if (!arg2) {
53380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53381     return ;
53382   }
53383   {
53384     try {
53385       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53386     } catch (std::out_of_range& e) {
53387       {
53388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53389       };
53390     } catch (std::exception& e) {
53391       {
53392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53393       };
53394     } catch (Dali::DaliException e) {
53395       {
53396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53397       };
53398     } catch (...) {
53399       {
53400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53401       };
53402     }
53403   }
53404
53405 }
53406
53407
53408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53409   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53410   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53411   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53412
53413   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53414   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53415   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53416   if (!arg3) {
53417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53418     return ;
53419   }
53420   {
53421     try {
53422       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53423     } catch (std::out_of_range& e) {
53424       {
53425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53426       };
53427     } catch (std::exception& e) {
53428       {
53429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53430       };
53431     } catch (Dali::DaliException e) {
53432       {
53433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53434       };
53435     } catch (...) {
53436       {
53437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53438       };
53439     }
53440   }
53441
53442 }
53443
53444
53445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53446   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53447   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53448   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53449   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53450
53451   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53452   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53453   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53454   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53455   {
53456     try {
53457       (arg1)->Insert(arg2,arg3,arg4);
53458     } catch (std::out_of_range& e) {
53459       {
53460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53461       };
53462     } catch (std::exception& e) {
53463       {
53464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53465       };
53466     } catch (Dali::DaliException e) {
53467       {
53468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53469       };
53470     } catch (...) {
53471       {
53472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53473       };
53474     }
53475   }
53476
53477 }
53478
53479
53480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53481   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53482   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53483
53484   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53485   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53486   {
53487     try {
53488       (arg1)->Reserve(arg2);
53489     } catch (std::out_of_range& e) {
53490       {
53491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53492       };
53493     } catch (std::exception& e) {
53494       {
53495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53496       };
53497     } catch (Dali::DaliException e) {
53498       {
53499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53500       };
53501     } catch (...) {
53502       {
53503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53504       };
53505     }
53506   }
53507
53508 }
53509
53510
53511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53512   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53513   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53514
53515   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53516   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53517   {
53518     try {
53519       (arg1)->Resize(arg2);
53520     } catch (std::out_of_range& e) {
53521       {
53522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53523       };
53524     } catch (std::exception& e) {
53525       {
53526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53527       };
53528     } catch (Dali::DaliException e) {
53529       {
53530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53531       };
53532     } catch (...) {
53533       {
53534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53535       };
53536     }
53537   }
53538
53539 }
53540
53541
53542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53543   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53544   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53545   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53546
53547   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53548   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53549   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53550   if (!arg3) {
53551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53552     return ;
53553   }
53554   {
53555     try {
53556       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53557     } catch (std::out_of_range& e) {
53558       {
53559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53560       };
53561     } catch (std::exception& e) {
53562       {
53563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53564       };
53565     } catch (Dali::DaliException e) {
53566       {
53567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53568       };
53569     } catch (...) {
53570       {
53571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53572       };
53573     }
53574   }
53575
53576 }
53577
53578
53579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53580   void * jresult ;
53581   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53582   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53583   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53584
53585   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53586   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53587   {
53588     try {
53589       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53590     } catch (std::out_of_range& e) {
53591       {
53592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53593       };
53594     } catch (std::exception& e) {
53595       {
53596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53597       };
53598     } catch (Dali::DaliException e) {
53599       {
53600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53601       };
53602     } catch (...) {
53603       {
53604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53605       };
53606     }
53607   }
53608
53609   jresult = (void *)result;
53610   return jresult;
53611 }
53612
53613
53614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53615   void * jresult ;
53616   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53617   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53618   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53619   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53620
53621   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53622   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53623   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53624   {
53625     try {
53626       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53627     } catch (std::out_of_range& e) {
53628       {
53629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53630       };
53631     } catch (std::exception& e) {
53632       {
53633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53634       };
53635     } catch (Dali::DaliException e) {
53636       {
53637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53638       };
53639     } catch (...) {
53640       {
53641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53642       };
53643     }
53644   }
53645
53646   jresult = (void *)result;
53647   return jresult;
53648 }
53649
53650
53651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53652   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53653   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53654
53655   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53656   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53657   {
53658     try {
53659       (arg1)->Remove(arg2);
53660     } catch (std::out_of_range& e) {
53661       {
53662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53663       };
53664     } catch (std::exception& e) {
53665       {
53666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53667       };
53668     } catch (Dali::DaliException e) {
53669       {
53670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53671       };
53672     } catch (...) {
53673       {
53674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53675       };
53676     }
53677   }
53678
53679 }
53680
53681
53682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53683   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53684   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53685
53686   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53687   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53688   if (!arg2) {
53689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53690     return ;
53691   }
53692   {
53693     try {
53694       (arg1)->Swap(*arg2);
53695     } catch (std::out_of_range& e) {
53696       {
53697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53698       };
53699     } catch (std::exception& e) {
53700       {
53701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53702       };
53703     } catch (Dali::DaliException e) {
53704       {
53705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53706       };
53707     } catch (...) {
53708       {
53709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53710       };
53711     }
53712   }
53713
53714 }
53715
53716
53717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53718   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53719
53720   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53721   {
53722     try {
53723       (arg1)->Clear();
53724     } catch (std::out_of_range& e) {
53725       {
53726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53727       };
53728     } catch (std::exception& e) {
53729       {
53730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53731       };
53732     } catch (Dali::DaliException e) {
53733       {
53734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53735       };
53736     } catch (...) {
53737       {
53738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53739       };
53740     }
53741   }
53742
53743 }
53744
53745
53746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53747   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53748
53749   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53750   {
53751     try {
53752       (arg1)->Release();
53753     } catch (std::out_of_range& e) {
53754       {
53755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53756       };
53757     } catch (std::exception& e) {
53758       {
53759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53760       };
53761     } catch (Dali::DaliException e) {
53762       {
53763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53764       };
53765     } catch (...) {
53766       {
53767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53768       };
53769     }
53770   }
53771
53772 }
53773
53774
53775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53776   void * jresult ;
53777   Dali::Signal< void () > *result = 0 ;
53778
53779   {
53780     try {
53781       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53782     } catch (std::out_of_range& e) {
53783       {
53784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53785       };
53786     } catch (std::exception& e) {
53787       {
53788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53789       };
53790     } catch (Dali::DaliException e) {
53791       {
53792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53793       };
53794     } catch (...) {
53795       {
53796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53797       };
53798     }
53799   }
53800
53801   jresult = (void *)result;
53802   return jresult;
53803 }
53804
53805
53806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53807   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53808
53809   arg1 = (Dali::Signal< void () > *)jarg1;
53810   {
53811     try {
53812       delete arg1;
53813     } catch (std::out_of_range& e) {
53814       {
53815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53816       };
53817     } catch (std::exception& e) {
53818       {
53819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53820       };
53821     } catch (Dali::DaliException e) {
53822       {
53823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53824       };
53825     } catch (...) {
53826       {
53827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53828       };
53829     }
53830   }
53831
53832 }
53833
53834
53835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53836   unsigned int jresult ;
53837   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53838   bool result;
53839
53840   arg1 = (Dali::Signal< void () > *)jarg1;
53841   {
53842     try {
53843       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53844     } catch (std::out_of_range& e) {
53845       {
53846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53847       };
53848     } catch (std::exception& e) {
53849       {
53850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53851       };
53852     } catch (Dali::DaliException e) {
53853       {
53854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53855       };
53856     } catch (...) {
53857       {
53858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53859       };
53860     }
53861   }
53862
53863   jresult = result;
53864   return jresult;
53865 }
53866
53867
53868 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53869   unsigned long jresult ;
53870   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53871   std::size_t result;
53872
53873   arg1 = (Dali::Signal< void () > *)jarg1;
53874   {
53875     try {
53876       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53877     } catch (std::out_of_range& e) {
53878       {
53879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53880       };
53881     } catch (std::exception& e) {
53882       {
53883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53884       };
53885     } catch (Dali::DaliException e) {
53886       {
53887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53888       };
53889     } catch (...) {
53890       {
53891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53892       };
53893     }
53894   }
53895
53896   jresult = (unsigned long)result;
53897   return jresult;
53898 }
53899
53900
53901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53902   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53903   void (*arg2)() = (void (*)()) 0 ;
53904
53905   arg1 = (Dali::Signal< void () > *)jarg1;
53906   arg2 = (void (*)())jarg2;
53907   {
53908     try {
53909       (arg1)->Connect(arg2);
53910     } catch (std::out_of_range& e) {
53911       {
53912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53913       };
53914     } catch (std::exception& e) {
53915       {
53916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53917       };
53918     } catch (Dali::DaliException e) {
53919       {
53920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53921       };
53922     } catch (...) {
53923       {
53924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53925       };
53926     }
53927   }
53928
53929 }
53930
53931
53932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53933   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53934   void (*arg2)() = (void (*)()) 0 ;
53935
53936   arg1 = (Dali::Signal< void () > *)jarg1;
53937   arg2 = (void (*)())jarg2;
53938   {
53939     try {
53940       (arg1)->Disconnect(arg2);
53941     } catch (std::out_of_range& e) {
53942       {
53943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53944       };
53945     } catch (std::exception& e) {
53946       {
53947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53948       };
53949     } catch (Dali::DaliException e) {
53950       {
53951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53952       };
53953     } catch (...) {
53954       {
53955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53956       };
53957     }
53958   }
53959
53960 }
53961
53962
53963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53964   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53965   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53966   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53967
53968   arg1 = (Dali::Signal< void () > *)jarg1;
53969   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53970   arg3 = (Dali::FunctorDelegate *)jarg3;
53971   {
53972     try {
53973       (arg1)->Connect(arg2,arg3);
53974     } catch (std::out_of_range& e) {
53975       {
53976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53977       };
53978     } catch (std::exception& e) {
53979       {
53980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53981       };
53982     } catch (Dali::DaliException e) {
53983       {
53984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53985       };
53986     } catch (...) {
53987       {
53988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53989       };
53990     }
53991   }
53992
53993 }
53994
53995
53996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53997   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53998
53999   arg1 = (Dali::Signal< void () > *)jarg1;
54000   {
54001     try {
54002       (arg1)->Emit();
54003     } catch (std::out_of_range& e) {
54004       {
54005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54006       };
54007     } catch (std::exception& e) {
54008       {
54009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54010       };
54011     } catch (Dali::DaliException e) {
54012       {
54013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54014       };
54015     } catch (...) {
54016       {
54017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54018       };
54019     }
54020   }
54021
54022 }
54023
54024
54025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
54026   unsigned int jresult ;
54027   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54028   bool result;
54029
54030   arg1 = (Dali::Signal< void (float) > *)jarg1;
54031   {
54032     try {
54033       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
54034     } catch (std::out_of_range& e) {
54035       {
54036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54037       };
54038     } catch (std::exception& e) {
54039       {
54040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54041       };
54042     } catch (Dali::DaliException e) {
54043       {
54044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54045       };
54046     } catch (...) {
54047       {
54048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54049       };
54050     }
54051   }
54052
54053   jresult = result;
54054   return jresult;
54055 }
54056
54057
54058 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
54059   unsigned long jresult ;
54060   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54061   std::size_t result;
54062
54063   arg1 = (Dali::Signal< void (float) > *)jarg1;
54064   {
54065     try {
54066       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
54067     } catch (std::out_of_range& e) {
54068       {
54069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54070       };
54071     } catch (std::exception& e) {
54072       {
54073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54074       };
54075     } catch (Dali::DaliException e) {
54076       {
54077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54078       };
54079     } catch (...) {
54080       {
54081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54082       };
54083     }
54084   }
54085
54086   jresult = (unsigned long)result;
54087   return jresult;
54088 }
54089
54090
54091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
54092   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54093   void (*arg2)(float) = (void (*)(float)) 0 ;
54094
54095   arg1 = (Dali::Signal< void (float) > *)jarg1;
54096   arg2 = (void (*)(float))jarg2;
54097   {
54098     try {
54099       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
54100     } catch (std::out_of_range& e) {
54101       {
54102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54103       };
54104     } catch (std::exception& e) {
54105       {
54106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54107       };
54108     } catch (Dali::DaliException e) {
54109       {
54110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54111       };
54112     } catch (...) {
54113       {
54114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54115       };
54116     }
54117   }
54118
54119 }
54120
54121
54122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
54123   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54124   void (*arg2)(float) = (void (*)(float)) 0 ;
54125
54126   arg1 = (Dali::Signal< void (float) > *)jarg1;
54127   arg2 = (void (*)(float))jarg2;
54128   {
54129     try {
54130       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
54131     } catch (std::out_of_range& e) {
54132       {
54133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54134       };
54135     } catch (std::exception& e) {
54136       {
54137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54138       };
54139     } catch (Dali::DaliException e) {
54140       {
54141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54142       };
54143     } catch (...) {
54144       {
54145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54146       };
54147     }
54148   }
54149
54150 }
54151
54152
54153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
54154   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54155   float arg2 ;
54156
54157   arg1 = (Dali::Signal< void (float) > *)jarg1;
54158   arg2 = (float)jarg2;
54159   {
54160     try {
54161       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
54162     } catch (std::out_of_range& e) {
54163       {
54164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54165       };
54166     } catch (std::exception& e) {
54167       {
54168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54169       };
54170     } catch (Dali::DaliException e) {
54171       {
54172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54173       };
54174     } catch (...) {
54175       {
54176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54177       };
54178     }
54179   }
54180
54181 }
54182
54183
54184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54185   void * jresult ;
54186   Dali::Signal< void (float) > *result = 0 ;
54187
54188   {
54189     try {
54190       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54191     } catch (std::out_of_range& e) {
54192       {
54193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54194       };
54195     } catch (std::exception& e) {
54196       {
54197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54198       };
54199     } catch (Dali::DaliException e) {
54200       {
54201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54202       };
54203     } catch (...) {
54204       {
54205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54206       };
54207     }
54208   }
54209
54210   jresult = (void *)result;
54211   return jresult;
54212 }
54213
54214
54215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54216   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54217
54218   arg1 = (Dali::Signal< void (float) > *)jarg1;
54219   {
54220     try {
54221       delete arg1;
54222     } catch (std::out_of_range& e) {
54223       {
54224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54225       };
54226     } catch (std::exception& e) {
54227       {
54228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54229       };
54230     } catch (Dali::DaliException e) {
54231       {
54232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54233       };
54234     } catch (...) {
54235       {
54236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54237       };
54238     }
54239   }
54240
54241 }
54242
54243
54244 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54245   unsigned int jresult ;
54246   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54247   bool result;
54248
54249   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54250   {
54251     try {
54252       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54253     } catch (std::out_of_range& e) {
54254       {
54255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54256       };
54257     } catch (std::exception& e) {
54258       {
54259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54260       };
54261     } catch (Dali::DaliException e) {
54262       {
54263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54264       };
54265     } catch (...) {
54266       {
54267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54268       };
54269     }
54270   }
54271
54272   jresult = result;
54273   return jresult;
54274 }
54275
54276
54277 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54278   unsigned long jresult ;
54279   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54280   std::size_t result;
54281
54282   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54283   {
54284     try {
54285       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54286     } catch (std::out_of_range& e) {
54287       {
54288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54289       };
54290     } catch (std::exception& e) {
54291       {
54292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54293       };
54294     } catch (Dali::DaliException e) {
54295       {
54296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54297       };
54298     } catch (...) {
54299       {
54300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54301       };
54302     }
54303   }
54304
54305   jresult = (unsigned long)result;
54306   return jresult;
54307 }
54308
54309
54310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54311   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54312   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54313
54314   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54315   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54316   {
54317     try {
54318       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54319     } catch (std::out_of_range& e) {
54320       {
54321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54322       };
54323     } catch (std::exception& e) {
54324       {
54325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54326       };
54327     } catch (Dali::DaliException e) {
54328       {
54329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54330       };
54331     } catch (...) {
54332       {
54333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54334       };
54335     }
54336   }
54337
54338 }
54339
54340
54341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54342   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54343   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54344
54345   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54346   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54347   {
54348     try {
54349       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54350     } catch (std::out_of_range& e) {
54351       {
54352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54353       };
54354     } catch (std::exception& e) {
54355       {
54356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54357       };
54358     } catch (Dali::DaliException e) {
54359       {
54360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54361       };
54362     } catch (...) {
54363       {
54364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54365       };
54366     }
54367   }
54368
54369 }
54370
54371
54372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54373   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54374   Dali::BaseHandle arg2 ;
54375   Dali::BaseHandle *argp2 ;
54376
54377   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54378   argp2 = (Dali::BaseHandle *)jarg2;
54379   if (!argp2) {
54380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54381     return ;
54382   }
54383   arg2 = *argp2;
54384   {
54385     try {
54386       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54387     } catch (std::out_of_range& e) {
54388       {
54389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54390       };
54391     } catch (std::exception& e) {
54392       {
54393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54394       };
54395     } catch (Dali::DaliException e) {
54396       {
54397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54398       };
54399     } catch (...) {
54400       {
54401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54402       };
54403     }
54404   }
54405
54406 }
54407
54408
54409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54410   void * jresult ;
54411   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54412
54413   {
54414     try {
54415       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54416     } catch (std::out_of_range& e) {
54417       {
54418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54419       };
54420     } catch (std::exception& e) {
54421       {
54422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54423       };
54424     } catch (Dali::DaliException e) {
54425       {
54426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54427       };
54428     } catch (...) {
54429       {
54430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54431       };
54432     }
54433   }
54434
54435   jresult = (void *)result;
54436   return jresult;
54437 }
54438
54439
54440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54441   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54442
54443   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54444   {
54445     try {
54446       delete arg1;
54447     } catch (std::out_of_range& e) {
54448       {
54449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54450       };
54451     } catch (std::exception& e) {
54452       {
54453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54454       };
54455     } catch (Dali::DaliException e) {
54456       {
54457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54458       };
54459     } catch (...) {
54460       {
54461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54462       };
54463     }
54464   }
54465
54466 }
54467
54468
54469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54470   unsigned int jresult ;
54471   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54472   bool result;
54473
54474   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54475   {
54476     try {
54477       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54478     } catch (std::out_of_range& e) {
54479       {
54480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54481       };
54482     } catch (std::exception& e) {
54483       {
54484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54485       };
54486     } catch (Dali::DaliException e) {
54487       {
54488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54489       };
54490     } catch (...) {
54491       {
54492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54493       };
54494     }
54495   }
54496
54497   jresult = result;
54498   return jresult;
54499 }
54500
54501
54502 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54503   unsigned long jresult ;
54504   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54505   std::size_t result;
54506
54507   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54508   {
54509     try {
54510       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54511     } catch (std::out_of_range& e) {
54512       {
54513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54514       };
54515     } catch (std::exception& e) {
54516       {
54517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54518       };
54519     } catch (Dali::DaliException e) {
54520       {
54521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54522       };
54523     } catch (...) {
54524       {
54525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54526       };
54527     }
54528   }
54529
54530   jresult = (unsigned long)result;
54531   return jresult;
54532 }
54533
54534
54535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54536   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54537   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54538
54539   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54540   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54541   {
54542     try {
54543       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54544     } catch (std::out_of_range& e) {
54545       {
54546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54547       };
54548     } catch (std::exception& e) {
54549       {
54550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54551       };
54552     } catch (Dali::DaliException e) {
54553       {
54554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54555       };
54556     } catch (...) {
54557       {
54558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54559       };
54560     }
54561   }
54562
54563 }
54564
54565
54566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54567   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54568   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54569
54570   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54571   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54572   {
54573     try {
54574       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54575     } catch (std::out_of_range& e) {
54576       {
54577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54578       };
54579     } catch (std::exception& e) {
54580       {
54581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54582       };
54583     } catch (Dali::DaliException e) {
54584       {
54585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54586       };
54587     } catch (...) {
54588       {
54589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54590       };
54591     }
54592   }
54593
54594 }
54595
54596
54597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54598   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54599   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54600
54601   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54602   arg2 = (Dali::RefObject *)jarg2;
54603   {
54604     try {
54605       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54606     } catch (std::out_of_range& e) {
54607       {
54608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54609       };
54610     } catch (std::exception& e) {
54611       {
54612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54613       };
54614     } catch (Dali::DaliException e) {
54615       {
54616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54617       };
54618     } catch (...) {
54619       {
54620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54621       };
54622     }
54623   }
54624
54625 }
54626
54627
54628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54629   void * jresult ;
54630   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54631
54632   {
54633     try {
54634       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54635     } catch (std::out_of_range& e) {
54636       {
54637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54638       };
54639     } catch (std::exception& e) {
54640       {
54641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54642       };
54643     } catch (Dali::DaliException e) {
54644       {
54645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54646       };
54647     } catch (...) {
54648       {
54649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54650       };
54651     }
54652   }
54653
54654   jresult = (void *)result;
54655   return jresult;
54656 }
54657
54658
54659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54660   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54661
54662   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54663   {
54664     try {
54665       delete arg1;
54666     } catch (std::out_of_range& e) {
54667       {
54668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54669       };
54670     } catch (std::exception& e) {
54671       {
54672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54673       };
54674     } catch (Dali::DaliException e) {
54675       {
54676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54677       };
54678     } catch (...) {
54679       {
54680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54681       };
54682     }
54683   }
54684
54685 }
54686
54687
54688 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54689   unsigned int jresult ;
54690   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54691   bool result;
54692
54693   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54694   {
54695     try {
54696       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54697     } catch (std::out_of_range& e) {
54698       {
54699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54700       };
54701     } catch (std::exception& e) {
54702       {
54703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54704       };
54705     } catch (Dali::DaliException e) {
54706       {
54707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54708       };
54709     } catch (...) {
54710       {
54711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54712       };
54713     }
54714   }
54715
54716   jresult = result;
54717   return jresult;
54718 }
54719
54720
54721 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54722   unsigned long jresult ;
54723   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54724   std::size_t result;
54725
54726   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54727   {
54728     try {
54729       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54730     } catch (std::out_of_range& e) {
54731       {
54732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54733       };
54734     } catch (std::exception& e) {
54735       {
54736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54737       };
54738     } catch (Dali::DaliException e) {
54739       {
54740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54741       };
54742     } catch (...) {
54743       {
54744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54745       };
54746     }
54747   }
54748
54749   jresult = (unsigned long)result;
54750   return jresult;
54751 }
54752
54753
54754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54755   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54756   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54757
54758   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54759   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54760   {
54761     try {
54762       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54763     } catch (std::out_of_range& e) {
54764       {
54765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54766       };
54767     } catch (std::exception& e) {
54768       {
54769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54770       };
54771     } catch (Dali::DaliException e) {
54772       {
54773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54774       };
54775     } catch (...) {
54776       {
54777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54778       };
54779     }
54780   }
54781
54782 }
54783
54784
54785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54786   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54787   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54788
54789   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54790   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54791   {
54792     try {
54793       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54794     } catch (std::out_of_range& e) {
54795       {
54796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54797       };
54798     } catch (std::exception& e) {
54799       {
54800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54801       };
54802     } catch (Dali::DaliException e) {
54803       {
54804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54805       };
54806     } catch (...) {
54807       {
54808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54809       };
54810     }
54811   }
54812
54813 }
54814
54815
54816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54817   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54818   Dali::PropertyNotification *arg2 = 0 ;
54819
54820   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54821   arg2 = (Dali::PropertyNotification *)jarg2;
54822   if (!arg2) {
54823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54824     return ;
54825   }
54826   {
54827     try {
54828       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54829     } catch (std::out_of_range& e) {
54830       {
54831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54832       };
54833     } catch (std::exception& e) {
54834       {
54835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54836       };
54837     } catch (Dali::DaliException e) {
54838       {
54839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54840       };
54841     } catch (...) {
54842       {
54843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54844       };
54845     }
54846   }
54847
54848 }
54849
54850
54851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54852   void * jresult ;
54853   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54854
54855   {
54856     try {
54857       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54858     } catch (std::out_of_range& e) {
54859       {
54860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54861       };
54862     } catch (std::exception& e) {
54863       {
54864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54865       };
54866     } catch (Dali::DaliException e) {
54867       {
54868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54869       };
54870     } catch (...) {
54871       {
54872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54873       };
54874     }
54875   }
54876
54877   jresult = (void *)result;
54878   return jresult;
54879 }
54880
54881
54882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54883   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54884
54885   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54886   {
54887     try {
54888       delete arg1;
54889     } catch (std::out_of_range& e) {
54890       {
54891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54892       };
54893     } catch (std::exception& e) {
54894       {
54895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54896       };
54897     } catch (Dali::DaliException e) {
54898       {
54899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54900       };
54901     } catch (...) {
54902       {
54903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54904       };
54905     }
54906   }
54907
54908 }
54909
54910
54911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54912   unsigned int jresult ;
54913   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54914   bool result;
54915
54916   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54917   {
54918     try {
54919       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54920     } catch (std::out_of_range& e) {
54921       {
54922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54923       };
54924     } catch (std::exception& e) {
54925       {
54926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54927       };
54928     } catch (Dali::DaliException e) {
54929       {
54930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54931       };
54932     } catch (...) {
54933       {
54934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54935       };
54936     }
54937   }
54938
54939   jresult = result;
54940   return jresult;
54941 }
54942
54943
54944 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54945   unsigned long jresult ;
54946   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54947   std::size_t result;
54948
54949   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54950   {
54951     try {
54952       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54953     } catch (std::out_of_range& e) {
54954       {
54955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54956       };
54957     } catch (std::exception& e) {
54958       {
54959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54960       };
54961     } catch (Dali::DaliException e) {
54962       {
54963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54964       };
54965     } catch (...) {
54966       {
54967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54968       };
54969     }
54970   }
54971
54972   jresult = (unsigned long)result;
54973   return jresult;
54974 }
54975
54976
54977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54978   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54979   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54980
54981   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54982   arg2 = (void (*)(Dali::Image))jarg2;
54983   {
54984     try {
54985       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54986     } catch (std::out_of_range& e) {
54987       {
54988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54989       };
54990     } catch (std::exception& e) {
54991       {
54992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54993       };
54994     } catch (Dali::DaliException e) {
54995       {
54996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54997       };
54998     } catch (...) {
54999       {
55000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55001       };
55002     }
55003   }
55004
55005 }
55006
55007
55008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
55009   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
55010   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
55011
55012   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
55013   arg2 = (void (*)(Dali::Image))jarg2;
55014   {
55015     try {
55016       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
55017     } catch (std::out_of_range& e) {
55018       {
55019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55020       };
55021     } catch (std::exception& e) {
55022       {
55023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55024       };
55025     } catch (Dali::DaliException e) {
55026       {
55027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55028       };
55029     } catch (...) {
55030       {
55031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55032       };
55033     }
55034   }
55035
55036 }
55037
55038
55039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
55040   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
55041   Dali::Image arg2 ;
55042   Dali::Image *argp2 ;
55043
55044   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
55045   argp2 = (Dali::Image *)jarg2;
55046   if (!argp2) {
55047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
55048     return ;
55049   }
55050   arg2 = *argp2;
55051   {
55052     try {
55053       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
55054     } catch (std::out_of_range& e) {
55055       {
55056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55057       };
55058     } catch (std::exception& e) {
55059       {
55060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55061       };
55062     } catch (Dali::DaliException e) {
55063       {
55064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55065       };
55066     } catch (...) {
55067       {
55068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55069       };
55070     }
55071   }
55072
55073 }
55074
55075
55076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
55077   void * jresult ;
55078   Dali::Signal< void (Dali::Image) > *result = 0 ;
55079
55080   {
55081     try {
55082       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
55083     } catch (std::out_of_range& e) {
55084       {
55085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55086       };
55087     } catch (std::exception& e) {
55088       {
55089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55090       };
55091     } catch (Dali::DaliException e) {
55092       {
55093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55094       };
55095     } catch (...) {
55096       {
55097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55098       };
55099     }
55100   }
55101
55102   jresult = (void *)result;
55103   return jresult;
55104 }
55105
55106
55107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
55108   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
55109
55110   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
55111   {
55112     try {
55113       delete arg1;
55114     } catch (std::out_of_range& e) {
55115       {
55116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55117       };
55118     } catch (std::exception& e) {
55119       {
55120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55121       };
55122     } catch (Dali::DaliException e) {
55123       {
55124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55125       };
55126     } catch (...) {
55127       {
55128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55129       };
55130     }
55131   }
55132
55133 }
55134
55135
55136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
55137   void * jresult ;
55138   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
55139
55140   {
55141     try {
55142       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
55143     } catch (std::out_of_range& e) {
55144       {
55145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55146       };
55147     } catch (std::exception& e) {
55148       {
55149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55150       };
55151     } catch (Dali::DaliException e) {
55152       {
55153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55154       };
55155     } catch (...) {
55156       {
55157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55158       };
55159     }
55160   }
55161
55162   jresult = (void *)result;
55163   return jresult;
55164 }
55165
55166
55167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
55168   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
55169
55170   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55171   {
55172     try {
55173       delete arg1;
55174     } catch (std::out_of_range& e) {
55175       {
55176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55177       };
55178     } catch (std::exception& e) {
55179       {
55180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55181       };
55182     } catch (Dali::DaliException e) {
55183       {
55184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55185       };
55186     } catch (...) {
55187       {
55188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55189       };
55190     }
55191   }
55192
55193 }
55194
55195
55196 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55197   unsigned int jresult ;
55198   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55199   bool result;
55200
55201   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55202   {
55203     try {
55204       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);
55205     } catch (std::out_of_range& e) {
55206       {
55207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55208       };
55209     } catch (std::exception& e) {
55210       {
55211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55212       };
55213     } catch (Dali::DaliException e) {
55214       {
55215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55216       };
55217     } catch (...) {
55218       {
55219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55220       };
55221     }
55222   }
55223
55224   jresult = result;
55225   return jresult;
55226 }
55227
55228
55229 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55230   unsigned long jresult ;
55231   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55232   std::size_t result;
55233
55234   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55235   {
55236     try {
55237       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);
55238     } catch (std::out_of_range& e) {
55239       {
55240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55241       };
55242     } catch (std::exception& e) {
55243       {
55244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55245       };
55246     } catch (Dali::DaliException e) {
55247       {
55248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55249       };
55250     } catch (...) {
55251       {
55252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55253       };
55254     }
55255   }
55256
55257   jresult = (unsigned long)result;
55258   return jresult;
55259 }
55260
55261
55262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55263   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55264   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55265
55266   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55267   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55268   {
55269     try {
55270       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55271     } catch (std::out_of_range& e) {
55272       {
55273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55274       };
55275     } catch (std::exception& e) {
55276       {
55277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55278       };
55279     } catch (Dali::DaliException e) {
55280       {
55281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55282       };
55283     } catch (...) {
55284       {
55285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55286       };
55287     }
55288   }
55289
55290 }
55291
55292
55293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55294   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55295   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55296
55297   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55298   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55299   {
55300     try {
55301       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55302     } catch (std::out_of_range& e) {
55303       {
55304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55305       };
55306     } catch (std::exception& e) {
55307       {
55308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55309       };
55310     } catch (Dali::DaliException e) {
55311       {
55312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55313       };
55314     } catch (...) {
55315       {
55316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55317       };
55318     }
55319   }
55320
55321 }
55322
55323
55324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55325   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55326   Dali::Actor arg2 ;
55327   Dali::LongPressGesture *arg3 = 0 ;
55328   Dali::Actor *argp2 ;
55329
55330   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55331   argp2 = (Dali::Actor *)jarg2;
55332   if (!argp2) {
55333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55334     return ;
55335   }
55336   arg2 = *argp2;
55337   arg3 = (Dali::LongPressGesture *)jarg3;
55338   if (!arg3) {
55339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55340     return ;
55341   }
55342   {
55343     try {
55344       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55345     } catch (std::out_of_range& e) {
55346       {
55347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55348       };
55349     } catch (std::exception& e) {
55350       {
55351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55352       };
55353     } catch (Dali::DaliException e) {
55354       {
55355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55356       };
55357     } catch (...) {
55358       {
55359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55360       };
55361     }
55362   }
55363
55364 }
55365
55366
55367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55368   void * jresult ;
55369   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55370
55371   {
55372     try {
55373       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55374     } catch (std::out_of_range& e) {
55375       {
55376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55377       };
55378     } catch (std::exception& e) {
55379       {
55380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55381       };
55382     } catch (Dali::DaliException e) {
55383       {
55384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55385       };
55386     } catch (...) {
55387       {
55388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55389       };
55390     }
55391   }
55392
55393   jresult = (void *)result;
55394   return jresult;
55395 }
55396
55397
55398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55399   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55400
55401   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55402   {
55403     try {
55404       delete arg1;
55405     } catch (std::out_of_range& e) {
55406       {
55407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55408       };
55409     } catch (std::exception& e) {
55410       {
55411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55412       };
55413     } catch (Dali::DaliException e) {
55414       {
55415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55416       };
55417     } catch (...) {
55418       {
55419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55420       };
55421     }
55422   }
55423
55424 }
55425
55426
55427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55428   unsigned int jresult ;
55429   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55430   bool result;
55431
55432   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55433   {
55434     try {
55435       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);
55436     } catch (std::out_of_range& e) {
55437       {
55438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55439       };
55440     } catch (std::exception& e) {
55441       {
55442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55443       };
55444     } catch (Dali::DaliException e) {
55445       {
55446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55447       };
55448     } catch (...) {
55449       {
55450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55451       };
55452     }
55453   }
55454
55455   jresult = result;
55456   return jresult;
55457 }
55458
55459
55460 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55461   unsigned long jresult ;
55462   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55463   std::size_t result;
55464
55465   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55466   {
55467     try {
55468       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);
55469     } catch (std::out_of_range& e) {
55470       {
55471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55472       };
55473     } catch (std::exception& e) {
55474       {
55475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55476       };
55477     } catch (Dali::DaliException e) {
55478       {
55479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55480       };
55481     } catch (...) {
55482       {
55483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55484       };
55485     }
55486   }
55487
55488   jresult = (unsigned long)result;
55489   return jresult;
55490 }
55491
55492
55493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55494   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55495   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55496
55497   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55498   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55499   {
55500     try {
55501       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55502     } catch (std::out_of_range& e) {
55503       {
55504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55505       };
55506     } catch (std::exception& e) {
55507       {
55508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55509       };
55510     } catch (Dali::DaliException e) {
55511       {
55512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55513       };
55514     } catch (...) {
55515       {
55516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55517       };
55518     }
55519   }
55520
55521 }
55522
55523
55524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55525   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55526   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55527
55528   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55529   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55530   {
55531     try {
55532       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55533     } catch (std::out_of_range& e) {
55534       {
55535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55536       };
55537     } catch (std::exception& e) {
55538       {
55539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55540       };
55541     } catch (Dali::DaliException e) {
55542       {
55543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55544       };
55545     } catch (...) {
55546       {
55547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55548       };
55549     }
55550   }
55551
55552 }
55553
55554
55555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55556   unsigned int jresult ;
55557   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55558   Dali::Actor arg2 ;
55559   Dali::TouchData *arg3 = 0 ;
55560   Dali::Actor *argp2 ;
55561   bool result;
55562
55563   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55564   argp2 = (Dali::Actor *)jarg2;
55565   if (!argp2) {
55566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55567     return 0;
55568   }
55569   arg2 = *argp2;
55570   arg3 = (Dali::TouchData *)jarg3;
55571   if (!arg3) {
55572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55573     return 0;
55574   }
55575   {
55576     try {
55577       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55578     } catch (std::out_of_range& e) {
55579       {
55580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55581       };
55582     } catch (std::exception& e) {
55583       {
55584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55585       };
55586     } catch (Dali::DaliException e) {
55587       {
55588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55589       };
55590     } catch (...) {
55591       {
55592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55593       };
55594     }
55595   }
55596
55597   jresult = result;
55598   return jresult;
55599 }
55600
55601
55602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55603   void * jresult ;
55604   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55605
55606   {
55607     try {
55608       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55609     } catch (std::out_of_range& e) {
55610       {
55611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55612       };
55613     } catch (std::exception& e) {
55614       {
55615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55616       };
55617     } catch (Dali::DaliException e) {
55618       {
55619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55620       };
55621     } catch (...) {
55622       {
55623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55624       };
55625     }
55626   }
55627
55628   jresult = (void *)result;
55629   return jresult;
55630 }
55631
55632
55633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55634   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55635
55636   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55637   {
55638     try {
55639       delete arg1;
55640     } catch (std::out_of_range& e) {
55641       {
55642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55643       };
55644     } catch (std::exception& e) {
55645       {
55646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55647       };
55648     } catch (Dali::DaliException e) {
55649       {
55650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55651       };
55652     } catch (...) {
55653       {
55654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55655       };
55656     }
55657   }
55658
55659 }
55660
55661
55662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55663   unsigned int jresult ;
55664   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55665   bool result;
55666
55667   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55668   {
55669     try {
55670       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);
55671     } catch (std::out_of_range& e) {
55672       {
55673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55674       };
55675     } catch (std::exception& e) {
55676       {
55677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55678       };
55679     } catch (Dali::DaliException e) {
55680       {
55681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55682       };
55683     } catch (...) {
55684       {
55685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55686       };
55687     }
55688   }
55689
55690   jresult = result;
55691   return jresult;
55692 }
55693
55694
55695 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55696   unsigned long jresult ;
55697   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55698   std::size_t result;
55699
55700   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55701   {
55702     try {
55703       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);
55704     } catch (std::out_of_range& e) {
55705       {
55706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55707       };
55708     } catch (std::exception& e) {
55709       {
55710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55711       };
55712     } catch (Dali::DaliException e) {
55713       {
55714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55715       };
55716     } catch (...) {
55717       {
55718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55719       };
55720     }
55721   }
55722
55723   jresult = (unsigned long)result;
55724   return jresult;
55725 }
55726
55727
55728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55729   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55730   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55731
55732   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55733   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55734   {
55735     try {
55736       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55737     } catch (std::out_of_range& e) {
55738       {
55739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55740       };
55741     } catch (std::exception& e) {
55742       {
55743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55744       };
55745     } catch (Dali::DaliException e) {
55746       {
55747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55748       };
55749     } catch (...) {
55750       {
55751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55752       };
55753     }
55754   }
55755
55756 }
55757
55758
55759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55760   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55761   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55762
55763   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55764   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55765   {
55766     try {
55767       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55768     } catch (std::out_of_range& e) {
55769       {
55770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55771       };
55772     } catch (std::exception& e) {
55773       {
55774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55775       };
55776     } catch (Dali::DaliException e) {
55777       {
55778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55779       };
55780     } catch (...) {
55781       {
55782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55783       };
55784     }
55785   }
55786
55787 }
55788
55789
55790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55791   unsigned int jresult ;
55792   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55793   Dali::Actor arg2 ;
55794   Dali::HoverEvent *arg3 = 0 ;
55795   Dali::Actor *argp2 ;
55796   bool result;
55797
55798   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55799   argp2 = (Dali::Actor *)jarg2;
55800   if (!argp2) {
55801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55802     return 0;
55803   }
55804   arg2 = *argp2;
55805   arg3 = (Dali::HoverEvent *)jarg3;
55806   if (!arg3) {
55807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55808     return 0;
55809   }
55810   {
55811     try {
55812       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55813     } catch (std::out_of_range& e) {
55814       {
55815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55816       };
55817     } catch (std::exception& e) {
55818       {
55819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55820       };
55821     } catch (Dali::DaliException e) {
55822       {
55823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55824       };
55825     } catch (...) {
55826       {
55827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55828       };
55829     }
55830   }
55831
55832   jresult = result;
55833   return jresult;
55834 }
55835
55836
55837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55838   void * jresult ;
55839   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55840
55841   {
55842     try {
55843       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55844     } catch (std::out_of_range& e) {
55845       {
55846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55847       };
55848     } catch (std::exception& e) {
55849       {
55850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55851       };
55852     } catch (Dali::DaliException e) {
55853       {
55854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55855       };
55856     } catch (...) {
55857       {
55858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55859       };
55860     }
55861   }
55862
55863   jresult = (void *)result;
55864   return jresult;
55865 }
55866
55867
55868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55869   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55870
55871   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55872   {
55873     try {
55874       delete arg1;
55875     } catch (std::out_of_range& e) {
55876       {
55877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55878       };
55879     } catch (std::exception& e) {
55880       {
55881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55882       };
55883     } catch (Dali::DaliException e) {
55884       {
55885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55886       };
55887     } catch (...) {
55888       {
55889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55890       };
55891     }
55892   }
55893
55894 }
55895
55896
55897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55898   unsigned int jresult ;
55899   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55900   bool result;
55901
55902   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55903   {
55904     try {
55905       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);
55906     } catch (std::out_of_range& e) {
55907       {
55908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55909       };
55910     } catch (std::exception& e) {
55911       {
55912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55913       };
55914     } catch (Dali::DaliException e) {
55915       {
55916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55917       };
55918     } catch (...) {
55919       {
55920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55921       };
55922     }
55923   }
55924
55925   jresult = result;
55926   return jresult;
55927 }
55928
55929
55930 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55931   unsigned long jresult ;
55932   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55933   std::size_t result;
55934
55935   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55936   {
55937     try {
55938       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);
55939     } catch (std::out_of_range& e) {
55940       {
55941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55942       };
55943     } catch (std::exception& e) {
55944       {
55945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55946       };
55947     } catch (Dali::DaliException e) {
55948       {
55949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55950       };
55951     } catch (...) {
55952       {
55953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55954       };
55955     }
55956   }
55957
55958   jresult = (unsigned long)result;
55959   return jresult;
55960 }
55961
55962
55963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55964   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55965   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55966
55967   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55968   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55969   {
55970     try {
55971       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55972     } catch (std::out_of_range& e) {
55973       {
55974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55975       };
55976     } catch (std::exception& e) {
55977       {
55978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55979       };
55980     } catch (Dali::DaliException e) {
55981       {
55982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55983       };
55984     } catch (...) {
55985       {
55986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55987       };
55988     }
55989   }
55990
55991 }
55992
55993
55994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55995   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55996   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55997
55998   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55999   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
56000   {
56001     try {
56002       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56003     } catch (std::out_of_range& e) {
56004       {
56005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56006       };
56007     } catch (std::exception& e) {
56008       {
56009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56010       };
56011     } catch (Dali::DaliException e) {
56012       {
56013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56014       };
56015     } catch (...) {
56016       {
56017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56018       };
56019     }
56020   }
56021
56022 }
56023
56024
56025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
56026   unsigned int jresult ;
56027   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
56028   Dali::Actor arg2 ;
56029   Dali::WheelEvent *arg3 = 0 ;
56030   Dali::Actor *argp2 ;
56031   bool result;
56032
56033   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
56034   argp2 = (Dali::Actor *)jarg2;
56035   if (!argp2) {
56036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56037     return 0;
56038   }
56039   arg2 = *argp2;
56040   arg3 = (Dali::WheelEvent *)jarg3;
56041   if (!arg3) {
56042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56043     return 0;
56044   }
56045   {
56046     try {
56047       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
56048     } catch (std::out_of_range& e) {
56049       {
56050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56051       };
56052     } catch (std::exception& e) {
56053       {
56054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56055       };
56056     } catch (Dali::DaliException e) {
56057       {
56058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56059       };
56060     } catch (...) {
56061       {
56062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56063       };
56064     }
56065   }
56066
56067   jresult = result;
56068   return jresult;
56069 }
56070
56071
56072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
56073   void * jresult ;
56074   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
56075
56076   {
56077     try {
56078       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
56079     } catch (std::out_of_range& e) {
56080       {
56081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56082       };
56083     } catch (std::exception& e) {
56084       {
56085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56086       };
56087     } catch (Dali::DaliException e) {
56088       {
56089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56090       };
56091     } catch (...) {
56092       {
56093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56094       };
56095     }
56096   }
56097
56098   jresult = (void *)result;
56099   return jresult;
56100 }
56101
56102
56103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
56104   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
56105
56106   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
56107   {
56108     try {
56109       delete arg1;
56110     } catch (std::out_of_range& e) {
56111       {
56112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56113       };
56114     } catch (std::exception& e) {
56115       {
56116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56117       };
56118     } catch (Dali::DaliException e) {
56119       {
56120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56121       };
56122     } catch (...) {
56123       {
56124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56125       };
56126     }
56127   }
56128
56129 }
56130
56131
56132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
56133   unsigned int jresult ;
56134   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56135   bool result;
56136
56137   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56138   {
56139     try {
56140       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
56141     } catch (std::out_of_range& e) {
56142       {
56143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56144       };
56145     } catch (std::exception& e) {
56146       {
56147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56148       };
56149     } catch (Dali::DaliException e) {
56150       {
56151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56152       };
56153     } catch (...) {
56154       {
56155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56156       };
56157     }
56158   }
56159
56160   jresult = result;
56161   return jresult;
56162 }
56163
56164
56165 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
56166   unsigned long jresult ;
56167   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56168   std::size_t result;
56169
56170   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56171   {
56172     try {
56173       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56174     } catch (std::out_of_range& e) {
56175       {
56176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56177       };
56178     } catch (std::exception& e) {
56179       {
56180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56181       };
56182     } catch (Dali::DaliException e) {
56183       {
56184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56185       };
56186     } catch (...) {
56187       {
56188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56189       };
56190     }
56191   }
56192
56193   jresult = (unsigned long)result;
56194   return jresult;
56195 }
56196
56197
56198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56199   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56200   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56201
56202   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56203   arg2 = (void (*)(Dali::Actor))jarg2;
56204   {
56205     try {
56206       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56207     } catch (std::out_of_range& e) {
56208       {
56209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56210       };
56211     } catch (std::exception& e) {
56212       {
56213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56214       };
56215     } catch (Dali::DaliException e) {
56216       {
56217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56218       };
56219     } catch (...) {
56220       {
56221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56222       };
56223     }
56224   }
56225
56226 }
56227
56228
56229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56230   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56231   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56232
56233   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56234   arg2 = (void (*)(Dali::Actor))jarg2;
56235   {
56236     try {
56237       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56238     } catch (std::out_of_range& e) {
56239       {
56240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56241       };
56242     } catch (std::exception& e) {
56243       {
56244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56245       };
56246     } catch (Dali::DaliException e) {
56247       {
56248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56249       };
56250     } catch (...) {
56251       {
56252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56253       };
56254     }
56255   }
56256
56257 }
56258
56259
56260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56261   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56262   Dali::Actor arg2 ;
56263   Dali::Actor *argp2 ;
56264
56265   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56266   argp2 = (Dali::Actor *)jarg2;
56267   if (!argp2) {
56268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56269     return ;
56270   }
56271   arg2 = *argp2;
56272   {
56273     try {
56274       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56275     } catch (std::out_of_range& e) {
56276       {
56277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56278       };
56279     } catch (std::exception& e) {
56280       {
56281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56282       };
56283     } catch (Dali::DaliException e) {
56284       {
56285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56286       };
56287     } catch (...) {
56288       {
56289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56290       };
56291     }
56292   }
56293
56294 }
56295
56296
56297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56298   void * jresult ;
56299   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56300
56301   {
56302     try {
56303       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56304     } catch (std::out_of_range& e) {
56305       {
56306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56307       };
56308     } catch (std::exception& e) {
56309       {
56310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56311       };
56312     } catch (Dali::DaliException e) {
56313       {
56314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56315       };
56316     } catch (...) {
56317       {
56318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56319       };
56320     }
56321   }
56322
56323   jresult = (void *)result;
56324   return jresult;
56325 }
56326
56327
56328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56329   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56330
56331   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56332   {
56333     try {
56334       delete arg1;
56335     } catch (std::out_of_range& e) {
56336       {
56337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56338       };
56339     } catch (std::exception& e) {
56340       {
56341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56342       };
56343     } catch (Dali::DaliException e) {
56344       {
56345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56346       };
56347     } catch (...) {
56348       {
56349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56350       };
56351     }
56352   }
56353
56354 }
56355
56356
56357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56358   unsigned int jresult ;
56359   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56360   bool result;
56361
56362   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56363   {
56364     try {
56365       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56366     } catch (std::out_of_range& e) {
56367       {
56368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56369       };
56370     } catch (std::exception& e) {
56371       {
56372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56373       };
56374     } catch (Dali::DaliException e) {
56375       {
56376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56377       };
56378     } catch (...) {
56379       {
56380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56381       };
56382     }
56383   }
56384
56385   jresult = result;
56386   return jresult;
56387 }
56388
56389
56390 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56391   unsigned long jresult ;
56392   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56393   std::size_t result;
56394
56395   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56396   {
56397     try {
56398       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56399     } catch (std::out_of_range& e) {
56400       {
56401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56402       };
56403     } catch (std::exception& e) {
56404       {
56405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56406       };
56407     } catch (Dali::DaliException e) {
56408       {
56409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56410       };
56411     } catch (...) {
56412       {
56413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56414       };
56415     }
56416   }
56417
56418   jresult = (unsigned long)result;
56419   return jresult;
56420 }
56421
56422
56423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56424   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56425   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56426
56427   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56428   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56429   {
56430     try {
56431       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56432     } catch (std::out_of_range& e) {
56433       {
56434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56435       };
56436     } catch (std::exception& e) {
56437       {
56438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56439       };
56440     } catch (Dali::DaliException e) {
56441       {
56442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56443       };
56444     } catch (...) {
56445       {
56446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56447       };
56448     }
56449   }
56450
56451 }
56452
56453
56454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56455   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56456   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56457
56458   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56459   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56460   {
56461     try {
56462       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56463     } catch (std::out_of_range& e) {
56464       {
56465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56466       };
56467     } catch (std::exception& e) {
56468       {
56469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56470       };
56471     } catch (Dali::DaliException e) {
56472       {
56473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56474       };
56475     } catch (...) {
56476       {
56477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56478       };
56479     }
56480   }
56481
56482 }
56483
56484
56485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56486   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56487   Dali::KeyEvent *arg2 = 0 ;
56488
56489   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56490   arg2 = (Dali::KeyEvent *)jarg2;
56491   if (!arg2) {
56492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56493     return ;
56494   }
56495   {
56496     try {
56497       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56498     } catch (std::out_of_range& e) {
56499       {
56500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56501       };
56502     } catch (std::exception& e) {
56503       {
56504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56505       };
56506     } catch (Dali::DaliException e) {
56507       {
56508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56509       };
56510     } catch (...) {
56511       {
56512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56513       };
56514     }
56515   }
56516
56517 }
56518
56519
56520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56521   void * jresult ;
56522   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56523
56524   {
56525     try {
56526       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56527     } catch (std::out_of_range& e) {
56528       {
56529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56530       };
56531     } catch (std::exception& e) {
56532       {
56533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56534       };
56535     } catch (Dali::DaliException e) {
56536       {
56537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56538       };
56539     } catch (...) {
56540       {
56541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56542       };
56543     }
56544   }
56545
56546   jresult = (void *)result;
56547   return jresult;
56548 }
56549
56550
56551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56552   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56553
56554   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56555   {
56556     try {
56557       delete arg1;
56558     } catch (std::out_of_range& e) {
56559       {
56560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56561       };
56562     } catch (std::exception& e) {
56563       {
56564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56565       };
56566     } catch (Dali::DaliException e) {
56567       {
56568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56569       };
56570     } catch (...) {
56571       {
56572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56573       };
56574     }
56575   }
56576
56577 }
56578
56579
56580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56581   unsigned int jresult ;
56582   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56583   bool result;
56584
56585   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56586   {
56587     try {
56588       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56589     } catch (std::out_of_range& e) {
56590       {
56591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56592       };
56593     } catch (std::exception& e) {
56594       {
56595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56596       };
56597     } catch (Dali::DaliException e) {
56598       {
56599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56600       };
56601     } catch (...) {
56602       {
56603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56604       };
56605     }
56606   }
56607
56608   jresult = result;
56609   return jresult;
56610 }
56611
56612
56613 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56614   unsigned long jresult ;
56615   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56616   std::size_t result;
56617
56618   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56619   {
56620     try {
56621       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56622     } catch (std::out_of_range& e) {
56623       {
56624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56625       };
56626     } catch (std::exception& e) {
56627       {
56628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56629       };
56630     } catch (Dali::DaliException e) {
56631       {
56632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56633       };
56634     } catch (...) {
56635       {
56636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56637       };
56638     }
56639   }
56640
56641   jresult = (unsigned long)result;
56642   return jresult;
56643 }
56644
56645
56646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56647   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56648   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56649
56650   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56651   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56652   {
56653     try {
56654       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56655     } catch (std::out_of_range& e) {
56656       {
56657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56658       };
56659     } catch (std::exception& e) {
56660       {
56661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56662       };
56663     } catch (Dali::DaliException e) {
56664       {
56665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56666       };
56667     } catch (...) {
56668       {
56669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56670       };
56671     }
56672   }
56673
56674 }
56675
56676
56677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56678   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56679   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56680
56681   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56682   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56683   {
56684     try {
56685       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56686     } catch (std::out_of_range& e) {
56687       {
56688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56689       };
56690     } catch (std::exception& e) {
56691       {
56692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56693       };
56694     } catch (Dali::DaliException e) {
56695       {
56696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56697       };
56698     } catch (...) {
56699       {
56700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56701       };
56702     }
56703   }
56704
56705 }
56706
56707
56708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56709   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56710   Dali::TouchData *arg2 = 0 ;
56711
56712   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56713   arg2 = (Dali::TouchData *)jarg2;
56714   if (!arg2) {
56715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56716     return ;
56717   }
56718   {
56719     try {
56720       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56721     } catch (std::out_of_range& e) {
56722       {
56723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56724       };
56725     } catch (std::exception& e) {
56726       {
56727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56728       };
56729     } catch (Dali::DaliException e) {
56730       {
56731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56732       };
56733     } catch (...) {
56734       {
56735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56736       };
56737     }
56738   }
56739
56740 }
56741
56742
56743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56744   void * jresult ;
56745   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56746
56747   {
56748     try {
56749       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56750     } catch (std::out_of_range& e) {
56751       {
56752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56753       };
56754     } catch (std::exception& e) {
56755       {
56756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56757       };
56758     } catch (Dali::DaliException e) {
56759       {
56760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56761       };
56762     } catch (...) {
56763       {
56764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56765       };
56766     }
56767   }
56768
56769   jresult = (void *)result;
56770   return jresult;
56771 }
56772
56773
56774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56775   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56776
56777   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56778   {
56779     try {
56780       delete arg1;
56781     } catch (std::out_of_range& e) {
56782       {
56783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56784       };
56785     } catch (std::exception& e) {
56786       {
56787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56788       };
56789     } catch (Dali::DaliException e) {
56790       {
56791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56792       };
56793     } catch (...) {
56794       {
56795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56796       };
56797     }
56798   }
56799
56800 }
56801
56802
56803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56804   unsigned int jresult ;
56805   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56806   bool result;
56807
56808   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56809   {
56810     try {
56811       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56812     } catch (std::out_of_range& e) {
56813       {
56814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56815       };
56816     } catch (std::exception& e) {
56817       {
56818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56819       };
56820     } catch (Dali::DaliException e) {
56821       {
56822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56823       };
56824     } catch (...) {
56825       {
56826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56827       };
56828     }
56829   }
56830
56831   jresult = result;
56832   return jresult;
56833 }
56834
56835
56836 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56837   unsigned long jresult ;
56838   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56839   std::size_t result;
56840
56841   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56842   {
56843     try {
56844       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56845     } catch (std::out_of_range& e) {
56846       {
56847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56848       };
56849     } catch (std::exception& e) {
56850       {
56851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56852       };
56853     } catch (Dali::DaliException e) {
56854       {
56855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56856       };
56857     } catch (...) {
56858       {
56859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56860       };
56861     }
56862   }
56863
56864   jresult = (unsigned long)result;
56865   return jresult;
56866 }
56867
56868
56869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56870   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56871   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56872
56873   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56874   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56875   {
56876     try {
56877       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56878     } catch (std::out_of_range& e) {
56879       {
56880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56881       };
56882     } catch (std::exception& e) {
56883       {
56884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56885       };
56886     } catch (Dali::DaliException e) {
56887       {
56888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56889       };
56890     } catch (...) {
56891       {
56892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56893       };
56894     }
56895   }
56896
56897 }
56898
56899
56900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56901   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56902   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56903
56904   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56905   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56906   {
56907     try {
56908       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56909     } catch (std::out_of_range& e) {
56910       {
56911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56912       };
56913     } catch (std::exception& e) {
56914       {
56915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56916       };
56917     } catch (Dali::DaliException e) {
56918       {
56919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56920       };
56921     } catch (...) {
56922       {
56923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56924       };
56925     }
56926   }
56927
56928 }
56929
56930
56931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56932   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56933   Dali::WheelEvent *arg2 = 0 ;
56934
56935   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56936   arg2 = (Dali::WheelEvent *)jarg2;
56937   if (!arg2) {
56938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56939     return ;
56940   }
56941   {
56942     try {
56943       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56944     } catch (std::out_of_range& e) {
56945       {
56946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56947       };
56948     } catch (std::exception& e) {
56949       {
56950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56951       };
56952     } catch (Dali::DaliException e) {
56953       {
56954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56955       };
56956     } catch (...) {
56957       {
56958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56959       };
56960     }
56961   }
56962
56963 }
56964
56965
56966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56967   void * jresult ;
56968   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56969
56970   {
56971     try {
56972       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56973     } catch (std::out_of_range& e) {
56974       {
56975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56976       };
56977     } catch (std::exception& e) {
56978       {
56979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56980       };
56981     } catch (Dali::DaliException e) {
56982       {
56983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56984       };
56985     } catch (...) {
56986       {
56987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56988       };
56989     }
56990   }
56991
56992   jresult = (void *)result;
56993   return jresult;
56994 }
56995
56996
56997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56998   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56999
57000   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
57001   {
57002     try {
57003       delete arg1;
57004     } catch (std::out_of_range& e) {
57005       {
57006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57007       };
57008     } catch (std::exception& e) {
57009       {
57010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57011       };
57012     } catch (Dali::DaliException e) {
57013       {
57014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57015       };
57016     } catch (...) {
57017       {
57018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57019       };
57020     }
57021   }
57022
57023 }
57024
57025
57026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
57027   void * jresult ;
57028   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
57029
57030   {
57031     try {
57032       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
57033     } catch (std::out_of_range& e) {
57034       {
57035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57036       };
57037     } catch (std::exception& e) {
57038       {
57039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57040       };
57041     } catch (Dali::DaliException e) {
57042       {
57043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57044       };
57045     } catch (...) {
57046       {
57047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57048       };
57049     }
57050   }
57051
57052   jresult = (void *)result;
57053   return jresult;
57054 }
57055
57056
57057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
57058   void * jresult ;
57059   Dali::Radian arg1 ;
57060   Dali::Radian arg2 ;
57061   Dali::Radian *argp1 ;
57062   Dali::Radian *argp2 ;
57063   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
57064
57065   argp1 = (Dali::Radian *)jarg1;
57066   if (!argp1) {
57067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
57068     return 0;
57069   }
57070   arg1 = *argp1;
57071   argp2 = (Dali::Radian *)jarg2;
57072   if (!argp2) {
57073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
57074     return 0;
57075   }
57076   arg2 = *argp2;
57077   {
57078     try {
57079       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
57080     } catch (std::out_of_range& e) {
57081       {
57082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57083       };
57084     } catch (std::exception& e) {
57085       {
57086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57087       };
57088     } catch (Dali::DaliException e) {
57089       {
57090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57091       };
57092     } catch (...) {
57093       {
57094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57095       };
57096     }
57097   }
57098
57099   jresult = (void *)result;
57100   return jresult;
57101 }
57102
57103
57104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
57105   void * jresult ;
57106   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
57107   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
57108
57109   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57110   if (!arg1) {
57111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
57112     return 0;
57113   }
57114   {
57115     try {
57116       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
57117     } catch (std::out_of_range& e) {
57118       {
57119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57120       };
57121     } catch (std::exception& e) {
57122       {
57123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57124       };
57125     } catch (Dali::DaliException e) {
57126       {
57127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57128       };
57129     } catch (...) {
57130       {
57131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57132       };
57133     }
57134   }
57135
57136   jresult = (void *)result;
57137   return jresult;
57138 }
57139
57140
57141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
57142   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57143   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57144
57145   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57146   arg2 = (Dali::Radian *)jarg2;
57147   if (arg1) (arg1)->first = *arg2;
57148 }
57149
57150
57151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
57152   void * jresult ;
57153   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57154   Dali::Radian *result = 0 ;
57155
57156   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57157   result = (Dali::Radian *)& ((arg1)->first);
57158   jresult = (void *)result;
57159   return jresult;
57160 }
57161
57162
57163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
57164   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57165   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57166
57167   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57168   arg2 = (Dali::Radian *)jarg2;
57169   if (arg1) (arg1)->second = *arg2;
57170 }
57171
57172
57173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57174   void * jresult ;
57175   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57176   Dali::Radian *result = 0 ;
57177
57178   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57179   result = (Dali::Radian *)& ((arg1)->second);
57180   jresult = (void *)result;
57181   return jresult;
57182 }
57183
57184
57185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57186   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57187
57188   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57189   {
57190     try {
57191       delete arg1;
57192     } catch (std::out_of_range& e) {
57193       {
57194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57195       };
57196     } catch (std::exception& e) {
57197       {
57198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57199       };
57200     } catch (Dali::DaliException e) {
57201       {
57202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57203       };
57204     } catch (...) {
57205       {
57206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57207       };
57208     }
57209   }
57210
57211 }
57212
57213
57214 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57215   unsigned int jresult ;
57216   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57217   bool result;
57218
57219   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57220   {
57221     try {
57222       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);
57223     } catch (std::out_of_range& e) {
57224       {
57225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57226       };
57227     } catch (std::exception& e) {
57228       {
57229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57230       };
57231     } catch (Dali::DaliException e) {
57232       {
57233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57234       };
57235     } catch (...) {
57236       {
57237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57238       };
57239     }
57240   }
57241
57242   jresult = result;
57243   return jresult;
57244 }
57245
57246
57247 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57248   unsigned long jresult ;
57249   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57250   std::size_t result;
57251
57252   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57253   {
57254     try {
57255       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);
57256     } catch (std::out_of_range& e) {
57257       {
57258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57259       };
57260     } catch (std::exception& e) {
57261       {
57262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57263       };
57264     } catch (Dali::DaliException e) {
57265       {
57266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57267       };
57268     } catch (...) {
57269       {
57270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57271       };
57272     }
57273   }
57274
57275   jresult = (unsigned long)result;
57276   return jresult;
57277 }
57278
57279
57280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57281   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57282   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57283
57284   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57285   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57286   {
57287     try {
57288       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57289     } catch (std::out_of_range& e) {
57290       {
57291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57292       };
57293     } catch (std::exception& e) {
57294       {
57295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57296       };
57297     } catch (Dali::DaliException e) {
57298       {
57299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57300       };
57301     } catch (...) {
57302       {
57303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57304       };
57305     }
57306   }
57307
57308 }
57309
57310
57311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57312   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57313   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57314
57315   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57316   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57317   {
57318     try {
57319       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57320     } catch (std::out_of_range& e) {
57321       {
57322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57323       };
57324     } catch (std::exception& e) {
57325       {
57326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57327       };
57328     } catch (Dali::DaliException e) {
57329       {
57330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57331       };
57332     } catch (...) {
57333       {
57334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57335       };
57336     }
57337   }
57338
57339 }
57340
57341
57342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57343   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57344   Dali::Actor arg2 ;
57345   Dali::PanGesture *arg3 = 0 ;
57346   Dali::Actor *argp2 ;
57347
57348   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57349   argp2 = (Dali::Actor *)jarg2;
57350   if (!argp2) {
57351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57352     return ;
57353   }
57354   arg2 = *argp2;
57355   arg3 = (Dali::PanGesture *)jarg3;
57356   if (!arg3) {
57357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57358     return ;
57359   }
57360   {
57361     try {
57362       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57363     } catch (std::out_of_range& e) {
57364       {
57365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57366       };
57367     } catch (std::exception& e) {
57368       {
57369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57370       };
57371     } catch (Dali::DaliException e) {
57372       {
57373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57374       };
57375     } catch (...) {
57376       {
57377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57378       };
57379     }
57380   }
57381
57382 }
57383
57384
57385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57386   void * jresult ;
57387   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57388
57389   {
57390     try {
57391       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57392     } catch (std::out_of_range& e) {
57393       {
57394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57395       };
57396     } catch (std::exception& e) {
57397       {
57398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57399       };
57400     } catch (Dali::DaliException e) {
57401       {
57402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57403       };
57404     } catch (...) {
57405       {
57406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57407       };
57408     }
57409   }
57410
57411   jresult = (void *)result;
57412   return jresult;
57413 }
57414
57415
57416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57417   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57418
57419   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57420   {
57421     try {
57422       delete arg1;
57423     } catch (std::out_of_range& e) {
57424       {
57425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57426       };
57427     } catch (std::exception& e) {
57428       {
57429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57430       };
57431     } catch (Dali::DaliException e) {
57432       {
57433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57434       };
57435     } catch (...) {
57436       {
57437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57438       };
57439     }
57440   }
57441
57442 }
57443
57444
57445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57446   unsigned int jresult ;
57447   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57448   bool result;
57449
57450   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57451   {
57452     try {
57453       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);
57454     } catch (std::out_of_range& e) {
57455       {
57456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57457       };
57458     } catch (std::exception& e) {
57459       {
57460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57461       };
57462     } catch (Dali::DaliException e) {
57463       {
57464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57465       };
57466     } catch (...) {
57467       {
57468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57469       };
57470     }
57471   }
57472
57473   jresult = result;
57474   return jresult;
57475 }
57476
57477
57478 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57479   unsigned long jresult ;
57480   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57481   std::size_t result;
57482
57483   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57484   {
57485     try {
57486       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);
57487     } catch (std::out_of_range& e) {
57488       {
57489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57490       };
57491     } catch (std::exception& e) {
57492       {
57493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57494       };
57495     } catch (Dali::DaliException e) {
57496       {
57497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57498       };
57499     } catch (...) {
57500       {
57501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57502       };
57503     }
57504   }
57505
57506   jresult = (unsigned long)result;
57507   return jresult;
57508 }
57509
57510
57511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57512   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57513   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57514
57515   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57516   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57517   {
57518     try {
57519       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57520     } catch (std::out_of_range& e) {
57521       {
57522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57523       };
57524     } catch (std::exception& e) {
57525       {
57526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57527       };
57528     } catch (Dali::DaliException e) {
57529       {
57530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57531       };
57532     } catch (...) {
57533       {
57534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57535       };
57536     }
57537   }
57538
57539 }
57540
57541
57542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57543   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57544   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57545
57546   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57547   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57548   {
57549     try {
57550       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57551     } catch (std::out_of_range& e) {
57552       {
57553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57554       };
57555     } catch (std::exception& e) {
57556       {
57557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57558       };
57559     } catch (Dali::DaliException e) {
57560       {
57561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57562       };
57563     } catch (...) {
57564       {
57565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57566       };
57567     }
57568   }
57569
57570 }
57571
57572
57573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57574   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57575   Dali::Actor arg2 ;
57576   Dali::PinchGesture *arg3 = 0 ;
57577   Dali::Actor *argp2 ;
57578
57579   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57580   argp2 = (Dali::Actor *)jarg2;
57581   if (!argp2) {
57582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57583     return ;
57584   }
57585   arg2 = *argp2;
57586   arg3 = (Dali::PinchGesture *)jarg3;
57587   if (!arg3) {
57588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57589     return ;
57590   }
57591   {
57592     try {
57593       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57594     } catch (std::out_of_range& e) {
57595       {
57596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57597       };
57598     } catch (std::exception& e) {
57599       {
57600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57601       };
57602     } catch (Dali::DaliException e) {
57603       {
57604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57605       };
57606     } catch (...) {
57607       {
57608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57609       };
57610     }
57611   }
57612
57613 }
57614
57615
57616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57617   void * jresult ;
57618   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57619
57620   {
57621     try {
57622       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57623     } catch (std::out_of_range& e) {
57624       {
57625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57626       };
57627     } catch (std::exception& e) {
57628       {
57629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57630       };
57631     } catch (Dali::DaliException e) {
57632       {
57633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57634       };
57635     } catch (...) {
57636       {
57637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57638       };
57639     }
57640   }
57641
57642   jresult = (void *)result;
57643   return jresult;
57644 }
57645
57646
57647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57648   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57649
57650   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57651   {
57652     try {
57653       delete arg1;
57654     } catch (std::out_of_range& e) {
57655       {
57656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57657       };
57658     } catch (std::exception& e) {
57659       {
57660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57661       };
57662     } catch (Dali::DaliException e) {
57663       {
57664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57665       };
57666     } catch (...) {
57667       {
57668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57669       };
57670     }
57671   }
57672
57673 }
57674
57675
57676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57677   unsigned int jresult ;
57678   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57679   bool result;
57680
57681   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57682   {
57683     try {
57684       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);
57685     } catch (std::out_of_range& e) {
57686       {
57687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57688       };
57689     } catch (std::exception& e) {
57690       {
57691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57692       };
57693     } catch (Dali::DaliException e) {
57694       {
57695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57696       };
57697     } catch (...) {
57698       {
57699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57700       };
57701     }
57702   }
57703
57704   jresult = result;
57705   return jresult;
57706 }
57707
57708
57709 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57710   unsigned long jresult ;
57711   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57712   std::size_t result;
57713
57714   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57715   {
57716     try {
57717       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);
57718     } catch (std::out_of_range& e) {
57719       {
57720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57721       };
57722     } catch (std::exception& e) {
57723       {
57724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57725       };
57726     } catch (Dali::DaliException e) {
57727       {
57728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57729       };
57730     } catch (...) {
57731       {
57732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57733       };
57734     }
57735   }
57736
57737   jresult = (unsigned long)result;
57738   return jresult;
57739 }
57740
57741
57742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57743   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57744   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57745
57746   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57747   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57748   {
57749     try {
57750       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57751     } catch (std::out_of_range& e) {
57752       {
57753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57754       };
57755     } catch (std::exception& e) {
57756       {
57757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57758       };
57759     } catch (Dali::DaliException e) {
57760       {
57761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57762       };
57763     } catch (...) {
57764       {
57765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57766       };
57767     }
57768   }
57769
57770 }
57771
57772
57773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57774   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57775   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57776
57777   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57778   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57779   {
57780     try {
57781       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57782     } catch (std::out_of_range& e) {
57783       {
57784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57785       };
57786     } catch (std::exception& e) {
57787       {
57788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57789       };
57790     } catch (Dali::DaliException e) {
57791       {
57792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57793       };
57794     } catch (...) {
57795       {
57796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57797       };
57798     }
57799   }
57800
57801 }
57802
57803
57804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57805   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57806   Dali::Actor arg2 ;
57807   Dali::TapGesture *arg3 = 0 ;
57808   Dali::Actor *argp2 ;
57809
57810   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57811   argp2 = (Dali::Actor *)jarg2;
57812   if (!argp2) {
57813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57814     return ;
57815   }
57816   arg2 = *argp2;
57817   arg3 = (Dali::TapGesture *)jarg3;
57818   if (!arg3) {
57819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57820     return ;
57821   }
57822   {
57823     try {
57824       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57825     } catch (std::out_of_range& e) {
57826       {
57827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57828       };
57829     } catch (std::exception& e) {
57830       {
57831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57832       };
57833     } catch (Dali::DaliException e) {
57834       {
57835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57836       };
57837     } catch (...) {
57838       {
57839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57840       };
57841     }
57842   }
57843
57844 }
57845
57846
57847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57848   void * jresult ;
57849   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57850
57851   {
57852     try {
57853       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57854     } catch (std::out_of_range& e) {
57855       {
57856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57857       };
57858     } catch (std::exception& e) {
57859       {
57860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57861       };
57862     } catch (Dali::DaliException e) {
57863       {
57864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57865       };
57866     } catch (...) {
57867       {
57868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57869       };
57870     }
57871   }
57872
57873   jresult = (void *)result;
57874   return jresult;
57875 }
57876
57877
57878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57879   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57880
57881   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57882   {
57883     try {
57884       delete arg1;
57885     } catch (std::out_of_range& e) {
57886       {
57887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57888       };
57889     } catch (std::exception& e) {
57890       {
57891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57892       };
57893     } catch (Dali::DaliException e) {
57894       {
57895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57896       };
57897     } catch (...) {
57898       {
57899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57900       };
57901     }
57902   }
57903
57904 }
57905
57906 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57907   unsigned int jresult ;
57908   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57909   bool result;
57910
57911   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57912   {
57913     try {
57914       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57915     } catch (std::out_of_range& e) {
57916       {
57917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57918       };
57919     } catch (std::exception& e) {
57920       {
57921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57922       };
57923     } catch (Dali::DaliException e) {
57924       {
57925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57926       };
57927     } catch (...) {
57928       {
57929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57930       };
57931     }
57932   }
57933
57934   jresult = result;
57935   return jresult;
57936 }
57937
57938
57939 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57940   unsigned long jresult ;
57941   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57942   std::size_t result;
57943
57944   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57945   {
57946     try {
57947       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57948     } catch (std::out_of_range& e) {
57949       {
57950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57951       };
57952     } catch (std::exception& e) {
57953       {
57954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57955       };
57956     } catch (Dali::DaliException e) {
57957       {
57958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57959       };
57960     } catch (...) {
57961       {
57962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57963       };
57964     }
57965   }
57966
57967   jresult = (unsigned long)result;
57968   return jresult;
57969 }
57970
57971
57972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57973   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57974   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57975
57976   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57977   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57978   {
57979     try {
57980       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57981     } catch (std::out_of_range& e) {
57982       {
57983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57984       };
57985     } catch (std::exception& e) {
57986       {
57987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57988       };
57989     } catch (Dali::DaliException e) {
57990       {
57991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57992       };
57993     } catch (...) {
57994       {
57995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57996       };
57997     }
57998   }
57999
58000 }
58001
58002
58003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
58004   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
58005   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
58006
58007   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
58008   arg2 = (void (*)(Dali::ResourceImage))jarg2;
58009   {
58010     try {
58011       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
58012     } catch (std::out_of_range& e) {
58013       {
58014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58015       };
58016     } catch (std::exception& e) {
58017       {
58018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58019       };
58020     } catch (Dali::DaliException e) {
58021       {
58022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58023       };
58024     } catch (...) {
58025       {
58026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58027       };
58028     }
58029   }
58030
58031 }
58032
58033
58034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
58035   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
58036   Dali::ResourceImage arg2 ;
58037   Dali::ResourceImage *argp2 ;
58038
58039   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
58040   argp2 = (Dali::ResourceImage *)jarg2;
58041   if (!argp2) {
58042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
58043     return ;
58044   }
58045   arg2 = *argp2;
58046   {
58047     try {
58048       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
58049     } catch (std::out_of_range& e) {
58050       {
58051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58052       };
58053     } catch (std::exception& e) {
58054       {
58055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58056       };
58057     } catch (Dali::DaliException e) {
58058       {
58059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58060       };
58061     } catch (...) {
58062       {
58063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58064       };
58065     }
58066   }
58067
58068 }
58069
58070
58071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
58072   void * jresult ;
58073   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
58074
58075   {
58076     try {
58077       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
58078     } catch (std::out_of_range& e) {
58079       {
58080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58081       };
58082     } catch (std::exception& e) {
58083       {
58084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58085       };
58086     } catch (Dali::DaliException e) {
58087       {
58088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58089       };
58090     } catch (...) {
58091       {
58092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58093       };
58094     }
58095   }
58096
58097   jresult = (void *)result;
58098   return jresult;
58099 }
58100
58101
58102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
58103   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
58104
58105   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
58106   {
58107     try {
58108       delete arg1;
58109     } catch (std::out_of_range& e) {
58110       {
58111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58112       };
58113     } catch (std::exception& e) {
58114       {
58115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58116       };
58117     } catch (Dali::DaliException e) {
58118       {
58119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58120       };
58121     } catch (...) {
58122       {
58123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58124       };
58125     }
58126   }
58127
58128 }
58129
58130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
58131   unsigned int jresult ;
58132   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58133   bool result = false;
58134
58135   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58136   {
58137     try {
58138       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);
58139     } catch (std::out_of_range& e) {
58140       {
58141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58142       };
58143     } catch (std::exception& e) {
58144       {
58145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58146       };
58147     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58148   }
58149   jresult = result;
58150   return jresult;
58151 }
58152
58153 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
58154   unsigned long jresult ;
58155   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58156   std::size_t result = 0;
58157
58158   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58159   {
58160     try {
58161       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);
58162     } catch (std::out_of_range& e) {
58163       {
58164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58165       };
58166     } catch (std::exception& e) {
58167       {
58168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58169       };
58170     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58171   }
58172   jresult = (unsigned long)result;
58173   return jresult;
58174 }
58175
58176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58177   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58178   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58179
58180   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58181   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58182   {
58183     try {
58184       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58185     } catch (std::out_of_range& e) {
58186       {
58187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58188       };
58189     } catch (std::exception& e) {
58190       {
58191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58192       };
58193     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58194   }
58195 }
58196
58197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58198   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58199   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58200
58201   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58202   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58203   {
58204     try {
58205       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58206     } catch (std::out_of_range& e) {
58207       {
58208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58209       };
58210     } catch (std::exception& e) {
58211       {
58212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58213       };
58214     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58215   }
58216 }
58217
58218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58219   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58220   Dali::Actor arg2 ;
58221   //bool arg3 ;
58222   Dali::LayoutDirection::Type arg4 ;
58223   Dali::Actor *argp2 ;
58224
58225   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58226   argp2 = (Dali::Actor *)jarg2;
58227   if (!argp2) {
58228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58229     return ;
58230   }
58231   arg2 = *argp2;
58232   //arg3 = jarg3 ? true : false;
58233   arg4 = (Dali::LayoutDirection::Type)jarg4;
58234   {
58235     try {
58236       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58237     } catch (std::out_of_range& e) {
58238       {
58239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58240       };
58241     } catch (std::exception& e) {
58242       {
58243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58244       };
58245     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58246   }
58247 }
58248
58249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58250   void * jresult ;
58251   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58252
58253   {
58254     try {
58255       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58256     } catch (std::out_of_range& e) {
58257       {
58258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58259       };
58260     } catch (std::exception& e) {
58261       {
58262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58263       };
58264     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58265   }
58266   jresult = (void *)result;
58267   return jresult;
58268 }
58269
58270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58271   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58272
58273   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58274   {
58275     try {
58276       delete arg1;
58277     } catch (std::out_of_range& e) {
58278       {
58279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58280       };
58281     } catch (std::exception& e) {
58282       {
58283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58284       };
58285     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58286   }
58287 }
58288
58289 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58290   unsigned int jresult ;
58291   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58292   bool result;
58293
58294   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58295   {
58296     try {
58297       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);
58298     } catch (std::out_of_range& e) {
58299       {
58300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58301       };
58302     } catch (std::exception& e) {
58303       {
58304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58305       };
58306     } catch (Dali::DaliException e) {
58307       {
58308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58309       };
58310     } catch (...) {
58311       {
58312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58313       };
58314     }
58315   }
58316
58317   jresult = result;
58318   return jresult;
58319 }
58320
58321
58322 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58323   unsigned long jresult ;
58324   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58325   std::size_t result;
58326
58327   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58328   {
58329     try {
58330       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);
58331     } catch (std::out_of_range& e) {
58332       {
58333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58334       };
58335     } catch (std::exception& e) {
58336       {
58337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58338       };
58339     } catch (Dali::DaliException e) {
58340       {
58341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58342       };
58343     } catch (...) {
58344       {
58345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58346       };
58347     }
58348   }
58349
58350   jresult = (unsigned long)result;
58351   return jresult;
58352 }
58353
58354
58355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58356   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58357   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58358
58359   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58360   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58361   {
58362     try {
58363       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58364     } catch (std::out_of_range& e) {
58365       {
58366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58367       };
58368     } catch (std::exception& e) {
58369       {
58370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58371       };
58372     } catch (Dali::DaliException e) {
58373       {
58374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58375       };
58376     } catch (...) {
58377       {
58378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58379       };
58380     }
58381   }
58382
58383 }
58384
58385
58386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58387   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58388   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58389
58390   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58391   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58392   {
58393     try {
58394       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58395     } catch (std::out_of_range& e) {
58396       {
58397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58398       };
58399     } catch (std::exception& e) {
58400       {
58401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58402       };
58403     } catch (Dali::DaliException e) {
58404       {
58405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58406       };
58407     } catch (...) {
58408       {
58409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58410       };
58411     }
58412   }
58413
58414 }
58415
58416
58417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58418   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58419   Dali::Actor arg2 ;
58420   bool arg3 ;
58421   Dali::DevelActor::VisibilityChange::Type arg4 ;
58422   Dali::Actor *argp2 ;
58423
58424   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58425   argp2 = (Dali::Actor *)jarg2;
58426   if (!argp2) {
58427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58428     return ;
58429   }
58430   arg2 = *argp2;
58431   arg3 = jarg3 ? true : false;
58432   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58433   {
58434     try {
58435       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58436     } catch (std::out_of_range& e) {
58437       {
58438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58439       };
58440     } catch (std::exception& e) {
58441       {
58442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58443       };
58444     } catch (Dali::DaliException e) {
58445       {
58446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58447       };
58448     } catch (...) {
58449       {
58450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58451       };
58452     }
58453   }
58454
58455 }
58456
58457
58458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58459   void * jresult ;
58460   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58461
58462   {
58463     try {
58464       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58465     } catch (std::out_of_range& e) {
58466       {
58467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58468       };
58469     } catch (std::exception& e) {
58470       {
58471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58472       };
58473     } catch (Dali::DaliException e) {
58474       {
58475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58476       };
58477     } catch (...) {
58478       {
58479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58480       };
58481     }
58482   }
58483
58484   jresult = (void *)result;
58485   return jresult;
58486 }
58487
58488
58489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58490   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58491
58492   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58493   {
58494     try {
58495       delete arg1;
58496     } catch (std::out_of_range& e) {
58497       {
58498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58499       };
58500     } catch (std::exception& e) {
58501       {
58502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58503       };
58504     } catch (Dali::DaliException e) {
58505       {
58506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58507       };
58508     } catch (...) {
58509       {
58510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58511       };
58512     }
58513   }
58514
58515 }
58516
58517
58518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58519   void * jresult ;
58520   Dali::Timer *result = 0 ;
58521
58522   {
58523     try {
58524       result = (Dali::Timer *)new Dali::Timer();
58525     } catch (std::out_of_range& e) {
58526       {
58527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58528       };
58529     } catch (std::exception& e) {
58530       {
58531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58532       };
58533     } catch (Dali::DaliException e) {
58534       {
58535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58536       };
58537     } catch (...) {
58538       {
58539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58540       };
58541     }
58542   }
58543
58544   jresult = (void *)result;
58545   return jresult;
58546 }
58547
58548
58549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58550   void * jresult ;
58551   unsigned int arg1 ;
58552   Dali::Timer result;
58553
58554   arg1 = (unsigned int)jarg1;
58555   {
58556     try {
58557       result = Dali::Timer::New(arg1);
58558     } catch (std::out_of_range& e) {
58559       {
58560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58561       };
58562     } catch (std::exception& e) {
58563       {
58564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58565       };
58566     } catch (Dali::DaliException e) {
58567       {
58568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58569       };
58570     } catch (...) {
58571       {
58572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58573       };
58574     }
58575   }
58576
58577   jresult = new Dali::Timer((const Dali::Timer &)result);
58578   return jresult;
58579 }
58580
58581
58582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58583   void * jresult ;
58584   Dali::Timer *arg1 = 0 ;
58585   Dali::Timer *result = 0 ;
58586
58587   arg1 = (Dali::Timer *)jarg1;
58588   if (!arg1) {
58589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58590     return 0;
58591   }
58592   {
58593     try {
58594       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58595     } catch (std::out_of_range& e) {
58596       {
58597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58598       };
58599     } catch (std::exception& e) {
58600       {
58601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58602       };
58603     } catch (Dali::DaliException e) {
58604       {
58605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58606       };
58607     } catch (...) {
58608       {
58609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58610       };
58611     }
58612   }
58613
58614   jresult = (void *)result;
58615   return jresult;
58616 }
58617
58618
58619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58620   void * jresult ;
58621   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58622   Dali::Timer *arg2 = 0 ;
58623   Dali::Timer *result = 0 ;
58624
58625   arg1 = (Dali::Timer *)jarg1;
58626   arg2 = (Dali::Timer *)jarg2;
58627   if (!arg2) {
58628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58629     return 0;
58630   }
58631   {
58632     try {
58633       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58634     } catch (std::out_of_range& e) {
58635       {
58636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58637       };
58638     } catch (std::exception& e) {
58639       {
58640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58641       };
58642     } catch (Dali::DaliException e) {
58643       {
58644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58645       };
58646     } catch (...) {
58647       {
58648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58649       };
58650     }
58651   }
58652
58653   jresult = (void *)result;
58654   return jresult;
58655 }
58656
58657
58658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58659   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58660
58661   arg1 = (Dali::Timer *)jarg1;
58662   {
58663     try {
58664       delete arg1;
58665     } catch (std::out_of_range& e) {
58666       {
58667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58668       };
58669     } catch (std::exception& e) {
58670       {
58671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58672       };
58673     } catch (Dali::DaliException e) {
58674       {
58675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58676       };
58677     } catch (...) {
58678       {
58679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58680       };
58681     }
58682   }
58683
58684 }
58685
58686
58687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58688   void * jresult ;
58689   Dali::BaseHandle arg1 ;
58690   Dali::BaseHandle *argp1 ;
58691   Dali::Timer result;
58692
58693   argp1 = (Dali::BaseHandle *)jarg1;
58694   if (!argp1) {
58695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58696     return 0;
58697   }
58698   arg1 = *argp1;
58699   {
58700     try {
58701       result = Dali::Timer::DownCast(arg1);
58702     } catch (std::out_of_range& e) {
58703       {
58704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58705       };
58706     } catch (std::exception& e) {
58707       {
58708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58709       };
58710     } catch (Dali::DaliException e) {
58711       {
58712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58713       };
58714     } catch (...) {
58715       {
58716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58717       };
58718     }
58719   }
58720
58721   jresult = new Dali::Timer((const Dali::Timer &)result);
58722   return jresult;
58723 }
58724
58725
58726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58727   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58728
58729   arg1 = (Dali::Timer *)jarg1;
58730   {
58731     try {
58732       (arg1)->Start();
58733     } catch (std::out_of_range& e) {
58734       {
58735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58736       };
58737     } catch (std::exception& e) {
58738       {
58739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58740       };
58741     } catch (Dali::DaliException e) {
58742       {
58743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58744       };
58745     } catch (...) {
58746       {
58747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58748       };
58749     }
58750   }
58751
58752 }
58753
58754
58755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58756   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58757
58758   arg1 = (Dali::Timer *)jarg1;
58759   {
58760     try {
58761       (arg1)->Stop();
58762     } catch (std::out_of_range& e) {
58763       {
58764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58765       };
58766     } catch (std::exception& e) {
58767       {
58768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58769       };
58770     } catch (Dali::DaliException e) {
58771       {
58772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58773       };
58774     } catch (...) {
58775       {
58776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58777       };
58778     }
58779   }
58780
58781 }
58782
58783
58784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58785   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58786   unsigned int arg2 ;
58787
58788   arg1 = (Dali::Timer *)jarg1;
58789   arg2 = (unsigned int)jarg2;
58790   {
58791     try {
58792       (arg1)->SetInterval(arg2);
58793     } catch (std::out_of_range& e) {
58794       {
58795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58796       };
58797     } catch (std::exception& e) {
58798       {
58799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58800       };
58801     } catch (Dali::DaliException e) {
58802       {
58803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58804       };
58805     } catch (...) {
58806       {
58807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58808       };
58809     }
58810   }
58811
58812 }
58813
58814
58815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58816   unsigned int jresult ;
58817   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58818   unsigned int result;
58819
58820   arg1 = (Dali::Timer *)jarg1;
58821   {
58822     try {
58823       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58824     } catch (std::out_of_range& e) {
58825       {
58826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58827       };
58828     } catch (std::exception& e) {
58829       {
58830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58831       };
58832     } catch (Dali::DaliException e) {
58833       {
58834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58835       };
58836     } catch (...) {
58837       {
58838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58839       };
58840     }
58841   }
58842
58843   jresult = result;
58844   return jresult;
58845 }
58846
58847
58848 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58849   unsigned int jresult ;
58850   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58851   bool result;
58852
58853   arg1 = (Dali::Timer *)jarg1;
58854   {
58855     try {
58856       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58857     } catch (std::out_of_range& e) {
58858       {
58859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58860       };
58861     } catch (std::exception& e) {
58862       {
58863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58864       };
58865     } catch (Dali::DaliException e) {
58866       {
58867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58868       };
58869     } catch (...) {
58870       {
58871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58872       };
58873     }
58874   }
58875
58876   jresult = result;
58877   return jresult;
58878 }
58879
58880
58881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58882   void * jresult ;
58883   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58884   Dali::Timer::TimerSignalType *result = 0 ;
58885
58886   arg1 = (Dali::Timer *)jarg1;
58887   {
58888     try {
58889       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58890     } catch (std::out_of_range& e) {
58891       {
58892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58893       };
58894     } catch (std::exception& e) {
58895       {
58896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58897       };
58898     } catch (Dali::DaliException e) {
58899       {
58900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58901       };
58902     } catch (...) {
58903       {
58904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58905       };
58906     }
58907   }
58908
58909   jresult = (void *)result;
58910   return jresult;
58911 }
58912
58913
58914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
58915   unsigned int jresult ;
58916   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58917   bool result;
58918
58919   arg1 = (Dali::Signal< bool () > *)jarg1;
58920   {
58921     try {
58922       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
58923     } catch (std::out_of_range& e) {
58924       {
58925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58926       };
58927     } catch (std::exception& e) {
58928       {
58929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58930       };
58931     } catch (Dali::DaliException e) {
58932       {
58933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58934       };
58935     } catch (...) {
58936       {
58937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58938       };
58939     }
58940   }
58941
58942   jresult = result;
58943   return jresult;
58944 }
58945
58946
58947 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
58948   unsigned long jresult ;
58949   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58950   std::size_t result;
58951
58952   arg1 = (Dali::Signal< bool () > *)jarg1;
58953   {
58954     try {
58955       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
58956     } catch (std::out_of_range& e) {
58957       {
58958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58959       };
58960     } catch (std::exception& e) {
58961       {
58962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58963       };
58964     } catch (Dali::DaliException e) {
58965       {
58966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58967       };
58968     } catch (...) {
58969       {
58970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58971       };
58972     }
58973   }
58974
58975   jresult = (unsigned long)result;
58976   return jresult;
58977 }
58978
58979
58980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
58981   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58982   bool (*arg2)() = (bool (*)()) 0 ;
58983
58984   arg1 = (Dali::Signal< bool () > *)jarg1;
58985   arg2 = (bool (*)())jarg2;
58986   {
58987     try {
58988       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
58989     } catch (std::out_of_range& e) {
58990       {
58991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58992       };
58993     } catch (std::exception& e) {
58994       {
58995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58996       };
58997     } catch (Dali::DaliException e) {
58998       {
58999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59000       };
59001     } catch (...) {
59002       {
59003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59004       };
59005     }
59006   }
59007
59008 }
59009
59010
59011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
59012   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59013   bool (*arg2)() = (bool (*)()) 0 ;
59014
59015   arg1 = (Dali::Signal< bool () > *)jarg1;
59016   arg2 = (bool (*)())jarg2;
59017   {
59018     try {
59019       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
59020     } catch (std::out_of_range& e) {
59021       {
59022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59023       };
59024     } catch (std::exception& e) {
59025       {
59026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59027       };
59028     } catch (Dali::DaliException e) {
59029       {
59030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59031       };
59032     } catch (...) {
59033       {
59034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59035       };
59036     }
59037   }
59038
59039 }
59040
59041
59042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
59043   unsigned int jresult ;
59044   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59045   bool result;
59046
59047   arg1 = (Dali::Signal< bool () > *)jarg1;
59048   {
59049     try {
59050       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
59051     } catch (std::out_of_range& e) {
59052       {
59053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59054       };
59055     } catch (std::exception& e) {
59056       {
59057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59058       };
59059     } catch (Dali::DaliException e) {
59060       {
59061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59062       };
59063     } catch (...) {
59064       {
59065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59066       };
59067     }
59068   }
59069
59070   jresult = result;
59071   return jresult;
59072 }
59073
59074
59075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
59076   void * jresult ;
59077   Dali::Signal< bool () > *result = 0 ;
59078
59079   {
59080     try {
59081       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59082     } catch (std::out_of_range& e) {
59083       {
59084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59085       };
59086     } catch (std::exception& e) {
59087       {
59088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59089       };
59090     } catch (Dali::DaliException e) {
59091       {
59092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59093       };
59094     } catch (...) {
59095       {
59096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59097       };
59098     }
59099   }
59100
59101   jresult = (void *)result;
59102   return jresult;
59103 }
59104
59105
59106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59107   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59108
59109   arg1 = (Dali::Signal< bool () > *)jarg1;
59110   {
59111     try {
59112       delete arg1;
59113     } catch (std::out_of_range& e) {
59114       {
59115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59116       };
59117     } catch (std::exception& e) {
59118       {
59119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59120       };
59121     } catch (Dali::DaliException e) {
59122       {
59123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59124       };
59125     } catch (...) {
59126       {
59127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59128       };
59129     }
59130   }
59131
59132 }
59133
59134
59135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59136   int jresult ;
59137   int result;
59138
59139   {
59140     try {
59141       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59142     } catch (std::out_of_range& e) {
59143       {
59144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59145       };
59146     } catch (std::exception& e) {
59147       {
59148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59149       };
59150     } catch (Dali::DaliException e) {
59151       {
59152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59153       };
59154     } catch (...) {
59155       {
59156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59157       };
59158     }
59159   }
59160
59161   jresult = (int)result;
59162   return jresult;
59163 }
59164
59165
59166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59167   int jresult ;
59168   int result;
59169
59170   {
59171     try {
59172       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59173     } catch (std::out_of_range& e) {
59174       {
59175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59176       };
59177     } catch (std::exception& e) {
59178       {
59179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59180       };
59181     } catch (Dali::DaliException e) {
59182       {
59183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59184       };
59185     } catch (...) {
59186       {
59187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59188       };
59189     }
59190   }
59191
59192   jresult = (int)result;
59193   return jresult;
59194 }
59195
59196
59197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59198   int jresult ;
59199   int result;
59200
59201   {
59202     try {
59203       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59204     } catch (std::out_of_range& e) {
59205       {
59206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59207       };
59208     } catch (std::exception& e) {
59209       {
59210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59211       };
59212     } catch (Dali::DaliException e) {
59213       {
59214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59215       };
59216     } catch (...) {
59217       {
59218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59219       };
59220     }
59221   }
59222
59223   jresult = (int)result;
59224   return jresult;
59225 }
59226
59227
59228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59229   int jresult ;
59230   int result;
59231
59232   {
59233     try {
59234       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59235     } catch (std::out_of_range& e) {
59236       {
59237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59238       };
59239     } catch (std::exception& e) {
59240       {
59241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59242       };
59243     } catch (Dali::DaliException e) {
59244       {
59245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59246       };
59247     } catch (...) {
59248       {
59249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59250       };
59251     }
59252   }
59253
59254   jresult = (int)result;
59255   return jresult;
59256 }
59257
59258
59259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59260   int jresult ;
59261   int result;
59262
59263   {
59264     try {
59265       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59266     } catch (std::out_of_range& e) {
59267       {
59268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59269       };
59270     } catch (std::exception& e) {
59271       {
59272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59273       };
59274     } catch (Dali::DaliException e) {
59275       {
59276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59277       };
59278     } catch (...) {
59279       {
59280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59281       };
59282     }
59283   }
59284
59285   jresult = (int)result;
59286   return jresult;
59287 }
59288
59289
59290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59291   int jresult ;
59292   int result;
59293
59294   {
59295     try {
59296       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59297     } catch (std::out_of_range& e) {
59298       {
59299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59300       };
59301     } catch (std::exception& e) {
59302       {
59303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59304       };
59305     } catch (Dali::DaliException e) {
59306       {
59307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59308       };
59309     } catch (...) {
59310       {
59311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59312       };
59313     }
59314   }
59315
59316   jresult = (int)result;
59317   return jresult;
59318 }
59319
59320
59321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59322   int jresult ;
59323   int result;
59324
59325   {
59326     try {
59327       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59328     } catch (std::out_of_range& e) {
59329       {
59330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59331       };
59332     } catch (std::exception& e) {
59333       {
59334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59335       };
59336     } catch (Dali::DaliException e) {
59337       {
59338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59339       };
59340     } catch (...) {
59341       {
59342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59343       };
59344     }
59345   }
59346
59347   jresult = (int)result;
59348   return jresult;
59349 }
59350
59351
59352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59353   int jresult ;
59354   int result;
59355
59356   {
59357     try {
59358       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59359     } catch (std::out_of_range& e) {
59360       {
59361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59362       };
59363     } catch (std::exception& e) {
59364       {
59365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59366       };
59367     } catch (Dali::DaliException e) {
59368       {
59369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59370       };
59371     } catch (...) {
59372       {
59373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59374       };
59375     }
59376   }
59377
59378   jresult = (int)result;
59379   return jresult;
59380 }
59381
59382
59383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59384   int jresult ;
59385   int result;
59386
59387   {
59388     try {
59389       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59390     } catch (std::out_of_range& e) {
59391       {
59392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59393       };
59394     } catch (std::exception& e) {
59395       {
59396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59397       };
59398     } catch (Dali::DaliException e) {
59399       {
59400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59401       };
59402     } catch (...) {
59403       {
59404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59405       };
59406     }
59407   }
59408
59409   jresult = (int)result;
59410   return jresult;
59411 }
59412
59413
59414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59415   int jresult ;
59416   int result;
59417
59418   {
59419     try {
59420       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59421     } catch (std::out_of_range& e) {
59422       {
59423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59424       };
59425     } catch (std::exception& e) {
59426       {
59427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59428       };
59429     } catch (Dali::DaliException e) {
59430       {
59431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59432       };
59433     } catch (...) {
59434       {
59435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59436       };
59437     }
59438   }
59439
59440   jresult = (int)result;
59441   return jresult;
59442 }
59443
59444
59445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59446   int jresult ;
59447   int result;
59448
59449   {
59450     try {
59451       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59452     } catch (std::out_of_range& e) {
59453       {
59454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59455       };
59456     } catch (std::exception& e) {
59457       {
59458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59459       };
59460     } catch (Dali::DaliException e) {
59461       {
59462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59463       };
59464     } catch (...) {
59465       {
59466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59467       };
59468     }
59469   }
59470
59471   jresult = (int)result;
59472   return jresult;
59473 }
59474
59475
59476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59477   int jresult ;
59478   int result;
59479
59480   {
59481     try {
59482       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59483     } catch (std::out_of_range& e) {
59484       {
59485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59486       };
59487     } catch (std::exception& e) {
59488       {
59489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59490       };
59491     } catch (Dali::DaliException e) {
59492       {
59493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59494       };
59495     } catch (...) {
59496       {
59497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59498       };
59499     }
59500   }
59501
59502   jresult = (int)result;
59503   return jresult;
59504 }
59505
59506
59507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59508   int jresult ;
59509   int result;
59510
59511   {
59512     try {
59513       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59514     } catch (std::out_of_range& e) {
59515       {
59516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59517       };
59518     } catch (std::exception& e) {
59519       {
59520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59521       };
59522     } catch (Dali::DaliException e) {
59523       {
59524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59525       };
59526     } catch (...) {
59527       {
59528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59529       };
59530     }
59531   }
59532
59533   jresult = (int)result;
59534   return jresult;
59535 }
59536
59537
59538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59539   int jresult ;
59540   int result;
59541
59542   {
59543     try {
59544       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59545     } catch (std::out_of_range& e) {
59546       {
59547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59548       };
59549     } catch (std::exception& e) {
59550       {
59551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59552       };
59553     } catch (Dali::DaliException e) {
59554       {
59555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59556       };
59557     } catch (...) {
59558       {
59559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59560       };
59561     }
59562   }
59563
59564   jresult = (int)result;
59565   return jresult;
59566 }
59567
59568
59569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59570   int jresult ;
59571   int result;
59572
59573   {
59574     try {
59575       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59576     } catch (std::out_of_range& e) {
59577       {
59578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59579       };
59580     } catch (std::exception& e) {
59581       {
59582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59583       };
59584     } catch (Dali::DaliException e) {
59585       {
59586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59587       };
59588     } catch (...) {
59589       {
59590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59591       };
59592     }
59593   }
59594
59595   jresult = (int)result;
59596   return jresult;
59597 }
59598
59599
59600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59601   int jresult ;
59602   int result;
59603
59604   {
59605     try {
59606       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59607     } catch (std::out_of_range& e) {
59608       {
59609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59610       };
59611     } catch (std::exception& e) {
59612       {
59613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59614       };
59615     } catch (Dali::DaliException e) {
59616       {
59617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59618       };
59619     } catch (...) {
59620       {
59621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59622       };
59623     }
59624   }
59625
59626   jresult = (int)result;
59627   return jresult;
59628 }
59629
59630
59631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59632   int jresult ;
59633   int result;
59634
59635   {
59636     try {
59637       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59638     } catch (std::out_of_range& e) {
59639       {
59640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59641       };
59642     } catch (std::exception& e) {
59643       {
59644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59645       };
59646     } catch (Dali::DaliException e) {
59647       {
59648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59649       };
59650     } catch (...) {
59651       {
59652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59653       };
59654     }
59655   }
59656
59657   jresult = (int)result;
59658   return jresult;
59659 }
59660
59661
59662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
59663   int jresult ;
59664   int result;
59665
59666   {
59667     try {
59668       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
59669     } catch (std::out_of_range& e) {
59670       {
59671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59672       };
59673     } catch (std::exception& e) {
59674       {
59675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59676       };
59677     } catch (Dali::DaliException e) {
59678       {
59679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59680       };
59681     } catch (...) {
59682       {
59683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59684       };
59685     }
59686   }
59687
59688   jresult = (int)result;
59689   return jresult;
59690 }
59691
59692
59693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
59694   int jresult ;
59695   int result;
59696
59697   {
59698     try {
59699       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
59700     } catch (std::out_of_range& e) {
59701       {
59702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59703       };
59704     } catch (std::exception& e) {
59705       {
59706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59707       };
59708     } catch (Dali::DaliException e) {
59709       {
59710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59711       };
59712     } catch (...) {
59713       {
59714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59715       };
59716     }
59717   }
59718
59719   jresult = (int)result;
59720   return jresult;
59721 }
59722
59723
59724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
59725   int jresult ;
59726   int result;
59727
59728   {
59729     try {
59730       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
59731     } catch (std::out_of_range& e) {
59732       {
59733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59734       };
59735     } catch (std::exception& e) {
59736       {
59737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59738       };
59739     } catch (Dali::DaliException e) {
59740       {
59741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59742       };
59743     } catch (...) {
59744       {
59745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59746       };
59747     }
59748   }
59749
59750   jresult = (int)result;
59751   return jresult;
59752 }
59753
59754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
59755   int jresult ;
59756   int result;
59757
59758   {
59759     try {
59760       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
59761     } catch (std::out_of_range& e) {
59762       {
59763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59764       };
59765     } catch (std::exception& e) {
59766       {
59767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59768       };
59769     } catch (Dali::DaliException e) {
59770       {
59771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59772       };
59773     } catch (...) {
59774       {
59775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59776       };
59777     }
59778   }
59779
59780   jresult = (int)result;
59781   return jresult;
59782 }
59783
59784
59785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
59786   int jresult ;
59787   int result;
59788   {
59789     try
59790     {
59791       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
59792     } catch (std::out_of_range& e) {
59793       {
59794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59795       };
59796     } catch (std::exception& e) {
59797       {
59798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59799       };
59800     } catch (Dali::DaliException e) {
59801       {
59802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59803       };
59804     } catch (...) {
59805       {
59806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59807       };
59808     }
59809   }
59810
59811   jresult = (int)result;
59812   return jresult;
59813 }
59814
59815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
59816   int jresult ;
59817   int result;
59818   {
59819     try
59820     {
59821       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
59822     } catch (std::out_of_range& e) {
59823       {
59824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59825       };
59826     } catch (std::exception& e) {
59827       {
59828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59829       };
59830     } catch (Dali::DaliException e) {
59831       {
59832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59833       };
59834     } catch (...) {
59835       {
59836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59837       };
59838     }
59839   }
59840
59841   jresult = (int)result;
59842   return jresult;
59843 }
59844
59845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
59846   int jresult ;
59847   int result;
59848   {
59849     try
59850     {
59851       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
59852     } catch (std::out_of_range& e) {
59853       {
59854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59855       };
59856     } catch (std::exception& e) {
59857       {
59858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59859       };
59860     } catch (Dali::DaliException e) {
59861       {
59862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59863       };
59864     } catch (...) {
59865       {
59866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59867       };
59868     }
59869   }
59870
59871   jresult = (int)result;
59872   return jresult;
59873 }
59874
59875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
59876   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
59877 }
59878
59879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
59880   int jresult ;
59881   int result;
59882   {
59883     try
59884     {
59885       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
59886     } catch (std::out_of_range& e) {
59887       {
59888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59889       };
59890     } catch (std::exception& e) {
59891       {
59892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59893       };
59894     } catch (Dali::DaliException e) {
59895       {
59896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59897       };
59898     } catch (...) {
59899       {
59900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59901       };
59902     }
59903   }
59904
59905   jresult = (int)result;
59906   return jresult;
59907 }
59908
59909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
59910   int jresult ;
59911   int result;
59912   {
59913     try
59914     {
59915       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
59916     } catch (std::out_of_range& e) {
59917       {
59918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59919       };
59920     } catch (std::exception& e) {
59921       {
59922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59923       };
59924     } catch (Dali::DaliException e) {
59925       {
59926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59927       };
59928     } catch (...) {
59929       {
59930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59931       };
59932     }
59933   }
59934
59935   jresult = (int)result;
59936   return jresult;
59937 }
59938
59939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
59940   int jresult ;
59941   int result;
59942
59943   {
59944     try {
59945       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
59946     } catch (std::out_of_range& e) {
59947       {
59948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59949       };
59950     } catch (std::exception& e) {
59951       {
59952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59953       };
59954     } catch (Dali::DaliException e) {
59955       {
59956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59957       };
59958     } catch (...) {
59959       {
59960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59961       };
59962     }
59963   }
59964
59965   jresult = (int)result;
59966   return jresult;
59967 }
59968
59969
59970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
59971   int jresult ;
59972   int result;
59973
59974   {
59975     try {
59976       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
59977     } catch (std::out_of_range& e) {
59978       {
59979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59980       };
59981     } catch (std::exception& e) {
59982       {
59983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59984       };
59985     } catch (Dali::DaliException e) {
59986       {
59987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59988       };
59989     } catch (...) {
59990       {
59991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59992       };
59993     }
59994   }
59995
59996   jresult = (int)result;
59997   return jresult;
59998 }
59999
60000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
60001   int jresult ;
60002   int result;
60003   {
60004     try
60005     {
60006       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
60007     } catch (std::out_of_range& e) {
60008       {
60009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60010       };
60011     } catch (std::exception& e) {
60012       {
60013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60014       };
60015     } catch (...) {
60016       {
60017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60018       };
60019     }
60020   }
60021   jresult = (int)result;
60022   return jresult;
60023 }
60024
60025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
60026   int jresult ;
60027   int result;
60028   {
60029     try
60030     {
60031       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
60032     } catch (std::out_of_range& e) {
60033       {
60034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60035       };
60036     } catch (std::exception& e) {
60037       {
60038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60039       };
60040     } catch (...) {
60041       {
60042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60043       };
60044     }
60045   }
60046   jresult = (int)result;
60047   return jresult;
60048 }
60049
60050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
60051   int jresult ;
60052   int result;
60053   {
60054     try
60055     {
60056       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
60057     } catch (std::out_of_range& e) {
60058       {
60059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60060       };
60061     } catch (std::exception& e) {
60062       {
60063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60064       };
60065     } catch (...) {
60066       {
60067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60068       };
60069     }
60070   }
60071   jresult = (int)result;
60072   return jresult;
60073 }
60074
60075
60076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
60077   int jresult ;
60078   int result;
60079   {
60080     try
60081     {
60082       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60083     } catch (std::out_of_range& e) {
60084       {
60085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60086       };
60087     } catch (std::exception& e) {
60088       {
60089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60090       };
60091     } catch (...) {
60092       {
60093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60094       };
60095     }
60096   }
60097   jresult = (int)result;
60098   return jresult;
60099 }
60100
60101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60102   int jresult ;
60103   int result;
60104   {
60105     try
60106     {
60107       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60108     } catch (std::out_of_range& e) {
60109       {
60110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60111       };
60112     } catch (std::exception& e) {
60113       {
60114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60115       };
60116     } catch (...) {
60117       {
60118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60119       };
60120     }
60121   }
60122   jresult = (int)result;
60123   return jresult;
60124 }
60125
60126
60127
60128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60129   int jresult ;
60130   int result;
60131
60132   {
60133     try {
60134       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60135     } catch (std::out_of_range& e) {
60136       {
60137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60138       };
60139     } catch (std::exception& e) {
60140       {
60141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60142       };
60143     } catch (Dali::DaliException e) {
60144       {
60145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60146       };
60147     } catch (...) {
60148       {
60149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60150       };
60151     }
60152   }
60153
60154   jresult = (int)result;
60155   return jresult;
60156 }
60157
60158
60159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60160   int jresult ;
60161   int result;
60162
60163   {
60164     try {
60165       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60166     } catch (std::out_of_range& e) {
60167       {
60168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60169       };
60170     } catch (std::exception& e) {
60171       {
60172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60173       };
60174     } catch (Dali::DaliException e) {
60175       {
60176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60177       };
60178     } catch (...) {
60179       {
60180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60181       };
60182     }
60183   }
60184
60185   jresult = (int)result;
60186   return jresult;
60187 }
60188
60189
60190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60191   int jresult ;
60192   int result;
60193
60194   {
60195     try {
60196       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60197     } catch (std::out_of_range& e) {
60198       {
60199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60200       };
60201     } catch (std::exception& e) {
60202       {
60203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60204       };
60205     } catch (Dali::DaliException e) {
60206       {
60207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60208       };
60209     } catch (...) {
60210       {
60211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60212       };
60213     }
60214   }
60215
60216   jresult = (int)result;
60217   return jresult;
60218 }
60219
60220
60221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60222   int jresult ;
60223   int result;
60224
60225   {
60226     try {
60227       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60228     } catch (std::out_of_range& e) {
60229       {
60230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60231       };
60232     } catch (std::exception& e) {
60233       {
60234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60235       };
60236     } catch (Dali::DaliException e) {
60237       {
60238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60239       };
60240     } catch (...) {
60241       {
60242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60243       };
60244     }
60245   }
60246
60247   jresult = (int)result;
60248   return jresult;
60249 }
60250
60251
60252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60253   int jresult ;
60254   int result;
60255
60256   {
60257     try {
60258       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60259     } catch (std::out_of_range& e) {
60260       {
60261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60262       };
60263     } catch (std::exception& e) {
60264       {
60265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60266       };
60267     } catch (Dali::DaliException e) {
60268       {
60269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60270       };
60271     } catch (...) {
60272       {
60273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60274       };
60275     }
60276   }
60277
60278   jresult = (int)result;
60279   return jresult;
60280 }
60281
60282
60283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60284   int jresult ;
60285   int result;
60286
60287   {
60288     try {
60289       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60290     } catch (std::out_of_range& e) {
60291       {
60292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60293       };
60294     } catch (std::exception& e) {
60295       {
60296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60297       };
60298     } catch (Dali::DaliException e) {
60299       {
60300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60301       };
60302     } catch (...) {
60303       {
60304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60305       };
60306     }
60307   }
60308
60309   jresult = (int)result;
60310   return jresult;
60311 }
60312
60313
60314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60315   int jresult ;
60316   int result;
60317
60318   {
60319     try {
60320       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60321     } catch (std::out_of_range& e) {
60322       {
60323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60324       };
60325     } catch (std::exception& e) {
60326       {
60327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60328       };
60329     } catch (Dali::DaliException e) {
60330       {
60331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60332       };
60333     } catch (...) {
60334       {
60335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60336       };
60337     }
60338   }
60339
60340   jresult = (int)result;
60341   return jresult;
60342 }
60343
60344 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60345   int jresult ;
60346   int result;
60347
60348   {
60349     try {
60350       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60351     } catch (std::out_of_range& e) {
60352       {
60353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60354       };
60355     } catch (std::exception& e) {
60356       {
60357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60358       };
60359     } catch (...) {
60360       {
60361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60362       };
60363     }
60364   }
60365   jresult = (int)result;
60366   return jresult;
60367 }
60368
60369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60370   int jresult ;
60371   int result;
60372
60373   {
60374     try {
60375       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60376     } catch (std::out_of_range& e) {
60377       {
60378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60379       };
60380     } catch (std::exception& e) {
60381       {
60382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60383       };
60384     } catch (Dali::DaliException e) {
60385       {
60386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60387       };
60388     } catch (...) {
60389       {
60390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60391       };
60392     }
60393   }
60394
60395   jresult = (int)result;
60396   return jresult;
60397 }
60398
60399
60400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60401   int jresult ;
60402   int result;
60403
60404   {
60405     try {
60406       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60407     } catch (std::out_of_range& e) {
60408       {
60409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60410       };
60411     } catch (std::exception& e) {
60412       {
60413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60414       };
60415     } catch (Dali::DaliException e) {
60416       {
60417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60418       };
60419     } catch (...) {
60420       {
60421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60422       };
60423     }
60424   }
60425
60426   jresult = (int)result;
60427   return jresult;
60428 }
60429
60430
60431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60432   int jresult ;
60433   int result;
60434
60435   {
60436     try {
60437       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60438     } catch (std::out_of_range& e) {
60439       {
60440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60441       };
60442     } catch (std::exception& e) {
60443       {
60444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60445       };
60446     } catch (Dali::DaliException e) {
60447       {
60448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60449       };
60450     } catch (...) {
60451       {
60452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60453       };
60454     }
60455   }
60456
60457   jresult = (int)result;
60458   return jresult;
60459 }
60460
60461
60462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60463   int jresult ;
60464   int result;
60465
60466   {
60467     try {
60468       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60469     } catch (std::out_of_range& e) {
60470       {
60471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60472       };
60473     } catch (std::exception& e) {
60474       {
60475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60476       };
60477     } catch (Dali::DaliException e) {
60478       {
60479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60480       };
60481     } catch (...) {
60482       {
60483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60484       };
60485     }
60486   }
60487
60488   jresult = (int)result;
60489   return jresult;
60490 }
60491
60492
60493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60494   int jresult ;
60495   int result;
60496
60497   {
60498     try {
60499       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60500     } catch (std::out_of_range& e) {
60501       {
60502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60503       };
60504     } catch (std::exception& e) {
60505       {
60506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60507       };
60508     } catch (Dali::DaliException e) {
60509       {
60510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60511       };
60512     } catch (...) {
60513       {
60514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60515       };
60516     }
60517   }
60518
60519   jresult = (int)result;
60520   return jresult;
60521 }
60522
60523
60524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60525   int jresult ;
60526   int result;
60527
60528   {
60529     try {
60530       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60531     } catch (std::out_of_range& e) {
60532       {
60533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60534       };
60535     } catch (std::exception& e) {
60536       {
60537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60538       };
60539     } catch (Dali::DaliException e) {
60540       {
60541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60542       };
60543     } catch (...) {
60544       {
60545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60546       };
60547     }
60548   }
60549
60550   jresult = (int)result;
60551   return jresult;
60552 }
60553
60554
60555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60556   int jresult ;
60557   int result;
60558
60559   {
60560     try {
60561       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60562     } catch (std::out_of_range& e) {
60563       {
60564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60565       };
60566     } catch (std::exception& e) {
60567       {
60568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60569       };
60570     } catch (Dali::DaliException e) {
60571       {
60572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60573       };
60574     } catch (...) {
60575       {
60576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60577       };
60578     }
60579   }
60580
60581   jresult = (int)result;
60582   return jresult;
60583 }
60584
60585
60586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60587   int jresult ;
60588   int result;
60589
60590   {
60591     try {
60592       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60593     } catch (std::out_of_range& e) {
60594       {
60595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60596       };
60597     } catch (std::exception& e) {
60598       {
60599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60600       };
60601     } catch (Dali::DaliException e) {
60602       {
60603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60604       };
60605     } catch (...) {
60606       {
60607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60608       };
60609     }
60610   }
60611
60612   jresult = (int)result;
60613   return jresult;
60614 }
60615
60616
60617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60618   int jresult ;
60619   int result;
60620
60621   {
60622     try {
60623       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60624     } catch (std::out_of_range& e) {
60625       {
60626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60627       };
60628     } catch (std::exception& e) {
60629       {
60630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60631       };
60632     } catch (Dali::DaliException e) {
60633       {
60634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60635       };
60636     } catch (...) {
60637       {
60638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60639       };
60640     }
60641   }
60642
60643   jresult = (int)result;
60644   return jresult;
60645 }
60646
60647
60648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60649   int jresult ;
60650   int result;
60651
60652   {
60653     try {
60654       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
60655     } catch (std::out_of_range& e) {
60656       {
60657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60658       };
60659     } catch (std::exception& e) {
60660       {
60661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60662       };
60663     } catch (Dali::DaliException e) {
60664       {
60665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60666       };
60667     } catch (...) {
60668       {
60669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60670       };
60671     }
60672   }
60673
60674   jresult = (int)result;
60675   return jresult;
60676 }
60677
60678
60679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
60680   int jresult ;
60681   int result;
60682
60683   {
60684     try {
60685       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
60686     } catch (std::out_of_range& e) {
60687       {
60688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60689       };
60690     } catch (std::exception& e) {
60691       {
60692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60693       };
60694     } catch (Dali::DaliException e) {
60695       {
60696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60697       };
60698     } catch (...) {
60699       {
60700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60701       };
60702     }
60703   }
60704
60705   jresult = (int)result;
60706   return jresult;
60707 }
60708
60709
60710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
60711   int jresult ;
60712   int result;
60713
60714   {
60715     try {
60716       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
60717     } catch (std::out_of_range& e) {
60718       {
60719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60720       };
60721     } catch (std::exception& e) {
60722       {
60723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60724       };
60725     } catch (Dali::DaliException e) {
60726       {
60727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60728       };
60729     } catch (...) {
60730       {
60731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60732       };
60733     }
60734   }
60735
60736   jresult = (int)result;
60737   return jresult;
60738 }
60739
60740
60741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
60742   int jresult ;
60743   int result;
60744
60745   {
60746     try {
60747       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
60748     } catch (std::out_of_range& e) {
60749       {
60750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60751       };
60752     } catch (std::exception& e) {
60753       {
60754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60755       };
60756     } catch (Dali::DaliException e) {
60757       {
60758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60759       };
60760     } catch (...) {
60761       {
60762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60763       };
60764     }
60765   }
60766
60767   jresult = (int)result;
60768   return jresult;
60769 }
60770
60771
60772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
60773   int jresult ;
60774   int result;
60775
60776   {
60777     try {
60778       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
60779     } catch (std::out_of_range& e) {
60780       {
60781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60782       };
60783     } catch (std::exception& e) {
60784       {
60785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60786       };
60787     } catch (Dali::DaliException e) {
60788       {
60789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60790       };
60791     } catch (...) {
60792       {
60793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60794       };
60795     }
60796   }
60797
60798   jresult = (int)result;
60799   return jresult;
60800 }
60801
60802
60803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
60804   int jresult ;
60805   int result;
60806
60807   {
60808     try {
60809       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
60810     } catch (std::out_of_range& e) {
60811       {
60812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60813       };
60814     } catch (std::exception& e) {
60815       {
60816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60817       };
60818     } catch (Dali::DaliException e) {
60819       {
60820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60821       };
60822     } catch (...) {
60823       {
60824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60825       };
60826     }
60827   }
60828
60829   jresult = (int)result;
60830   return jresult;
60831 }
60832
60833
60834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
60835   int jresult ;
60836   int result;
60837
60838   {
60839     try {
60840       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
60841     } catch (std::out_of_range& e) {
60842       {
60843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60844       };
60845     } catch (std::exception& e) {
60846       {
60847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60848       };
60849     } catch (Dali::DaliException e) {
60850       {
60851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60852       };
60853     } catch (...) {
60854       {
60855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60856       };
60857     }
60858   }
60859
60860   jresult = (int)result;
60861   return jresult;
60862 }
60863
60864
60865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
60866   int jresult ;
60867   int result;
60868
60869   {
60870     try {
60871       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
60872     } catch (std::out_of_range& e) {
60873       {
60874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60875       };
60876     } catch (std::exception& e) {
60877       {
60878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60879       };
60880     } catch (Dali::DaliException e) {
60881       {
60882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60883       };
60884     } catch (...) {
60885       {
60886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60887       };
60888     }
60889   }
60890
60891   jresult = (int)result;
60892   return jresult;
60893 }
60894
60895
60896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
60897   int jresult ;
60898   int result;
60899
60900   {
60901     try {
60902       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
60903     } catch (std::out_of_range& e) {
60904       {
60905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60906       };
60907     } catch (std::exception& e) {
60908       {
60909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60910       };
60911     } catch (Dali::DaliException e) {
60912       {
60913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60914       };
60915     } catch (...) {
60916       {
60917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60918       };
60919     }
60920   }
60921
60922   jresult = (int)result;
60923   return jresult;
60924 }
60925
60926
60927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
60928   int jresult ;
60929   int result;
60930
60931   {
60932     try {
60933       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
60934     } catch (std::out_of_range& e) {
60935       {
60936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60937       };
60938     } catch (std::exception& e) {
60939       {
60940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60941       };
60942     } catch (Dali::DaliException e) {
60943       {
60944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60945       };
60946     } catch (...) {
60947       {
60948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60949       };
60950     }
60951   }
60952
60953   jresult = (int)result;
60954   return jresult;
60955 }
60956
60957
60958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
60959   int jresult ;
60960   int result;
60961
60962   {
60963     try {
60964       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
60965     } catch (std::out_of_range& e) {
60966       {
60967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60968       };
60969     } catch (std::exception& e) {
60970       {
60971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60972       };
60973     } catch (Dali::DaliException e) {
60974       {
60975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60976       };
60977     } catch (...) {
60978       {
60979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60980       };
60981     }
60982   }
60983
60984   jresult = (int)result;
60985   return jresult;
60986 }
60987
60988
60989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
60990   int jresult ;
60991   int result;
60992
60993   {
60994     try {
60995       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
60996     } catch (std::out_of_range& e) {
60997       {
60998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60999       };
61000     } catch (std::exception& e) {
61001       {
61002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61003       };
61004     } catch (Dali::DaliException e) {
61005       {
61006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61007       };
61008     } catch (...) {
61009       {
61010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61011       };
61012     }
61013   }
61014
61015   jresult = (int)result;
61016   return jresult;
61017 }
61018
61019
61020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
61021   int jresult ;
61022   int result;
61023
61024   {
61025     try {
61026       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
61027     } catch (std::out_of_range& e) {
61028       {
61029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61030       };
61031     } catch (std::exception& e) {
61032       {
61033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61034       };
61035     } catch (Dali::DaliException e) {
61036       {
61037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61038       };
61039     } catch (...) {
61040       {
61041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61042       };
61043     }
61044   }
61045
61046   jresult = (int)result;
61047   return jresult;
61048 }
61049
61050
61051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
61052   int jresult ;
61053   int result;
61054
61055   {
61056     try {
61057       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
61058     } catch (std::out_of_range& e) {
61059       {
61060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61061       };
61062     } catch (std::exception& e) {
61063       {
61064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61065       };
61066     } catch (Dali::DaliException e) {
61067       {
61068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61069       };
61070     } catch (...) {
61071       {
61072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61073       };
61074     }
61075   }
61076
61077   jresult = (int)result;
61078   return jresult;
61079 }
61080
61081
61082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61083   int jresult ;
61084   int result;
61085
61086   {
61087     try {
61088       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61089     } catch (std::out_of_range& e) {
61090       {
61091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61092       };
61093     } catch (std::exception& e) {
61094       {
61095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61096       };
61097     } catch (Dali::DaliException e) {
61098       {
61099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61100       };
61101     } catch (...) {
61102       {
61103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61104       };
61105     }
61106   }
61107
61108   jresult = (int)result;
61109   return jresult;
61110 }
61111
61112
61113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61114   int jresult ;
61115   int result;
61116
61117   {
61118     try {
61119       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61120     } catch (std::out_of_range& e) {
61121       {
61122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61123       };
61124     } catch (std::exception& e) {
61125       {
61126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61127       };
61128     } catch (Dali::DaliException e) {
61129       {
61130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61131       };
61132     } catch (...) {
61133       {
61134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61135       };
61136     }
61137   }
61138
61139   jresult = (int)result;
61140   return jresult;
61141 }
61142
61143
61144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61145   int jresult ;
61146   int result;
61147
61148   {
61149     try {
61150       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61151     } catch (std::out_of_range& e) {
61152       {
61153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61154       };
61155     } catch (std::exception& e) {
61156       {
61157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61158       };
61159     } catch (Dali::DaliException e) {
61160       {
61161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61162       };
61163     } catch (...) {
61164       {
61165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61166       };
61167     }
61168   }
61169
61170   jresult = (int)result;
61171   return jresult;
61172 }
61173
61174
61175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61176   int jresult ;
61177   int result;
61178
61179   {
61180     try {
61181       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61182     } catch (std::out_of_range& e) {
61183       {
61184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61185       };
61186     } catch (std::exception& e) {
61187       {
61188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61189       };
61190     } catch (Dali::DaliException e) {
61191       {
61192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61193       };
61194     } catch (...) {
61195       {
61196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61197       };
61198     }
61199   }
61200
61201   jresult = (int)result;
61202   return jresult;
61203 }
61204
61205
61206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61207   int jresult ;
61208   int result;
61209
61210   {
61211     try {
61212       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61213     } catch (std::out_of_range& e) {
61214       {
61215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61216       };
61217     } catch (std::exception& e) {
61218       {
61219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61220       };
61221     } catch (Dali::DaliException e) {
61222       {
61223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61224       };
61225     } catch (...) {
61226       {
61227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61228       };
61229     }
61230   }
61231
61232   jresult = (int)result;
61233   return jresult;
61234 }
61235
61236
61237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61238   void * jresult ;
61239   Dali::Toolkit::Builder *result = 0 ;
61240
61241   {
61242     try {
61243       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61244     } catch (std::out_of_range& e) {
61245       {
61246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61247       };
61248     } catch (std::exception& e) {
61249       {
61250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61251       };
61252     } catch (Dali::DaliException e) {
61253       {
61254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61255       };
61256     } catch (...) {
61257       {
61258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61259       };
61260     }
61261   }
61262
61263   jresult = (void *)result;
61264   return jresult;
61265 }
61266
61267
61268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61269   void * jresult ;
61270   Dali::Toolkit::Builder result;
61271
61272   {
61273     try {
61274       result = Dali::Toolkit::Builder::New();
61275     } catch (std::out_of_range& e) {
61276       {
61277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61278       };
61279     } catch (std::exception& e) {
61280       {
61281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61282       };
61283     } catch (Dali::DaliException e) {
61284       {
61285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61286       };
61287     } catch (...) {
61288       {
61289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61290       };
61291     }
61292   }
61293
61294   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61295   return jresult;
61296 }
61297
61298
61299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61300   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61301
61302   arg1 = (Dali::Toolkit::Builder *)jarg1;
61303   {
61304     try {
61305       delete arg1;
61306     } catch (std::out_of_range& e) {
61307       {
61308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61309       };
61310     } catch (std::exception& e) {
61311       {
61312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61313       };
61314     } catch (Dali::DaliException e) {
61315       {
61316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61317       };
61318     } catch (...) {
61319       {
61320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61321       };
61322     }
61323   }
61324
61325 }
61326
61327
61328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61329   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61330   std::string *arg2 = 0 ;
61331   Dali::Toolkit::Builder::UIFormat arg3 ;
61332
61333   arg1 = (Dali::Toolkit::Builder *)jarg1;
61334   if (!jarg2) {
61335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61336     return ;
61337   }
61338   std::string arg2_str(jarg2);
61339   arg2 = &arg2_str;
61340   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61341   {
61342     try {
61343       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61344     } catch (std::out_of_range& e) {
61345       {
61346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61347       };
61348     } catch (std::exception& e) {
61349       {
61350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61351       };
61352     } catch (Dali::DaliException e) {
61353       {
61354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61355       };
61356     } catch (...) {
61357       {
61358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61359       };
61360     }
61361   }
61362
61363
61364   //argout typemap for const std::string&
61365
61366 }
61367
61368
61369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61370   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61371   std::string *arg2 = 0 ;
61372
61373   arg1 = (Dali::Toolkit::Builder *)jarg1;
61374   if (!jarg2) {
61375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61376     return ;
61377   }
61378   std::string arg2_str(jarg2);
61379   arg2 = &arg2_str;
61380   {
61381     try {
61382       (arg1)->LoadFromString((std::string const &)*arg2);
61383     } catch (std::out_of_range& e) {
61384       {
61385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61386       };
61387     } catch (std::exception& e) {
61388       {
61389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61390       };
61391     } catch (Dali::DaliException e) {
61392       {
61393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61394       };
61395     } catch (...) {
61396       {
61397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61398       };
61399     }
61400   }
61401
61402
61403   //argout typemap for const std::string&
61404
61405 }
61406
61407
61408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61409   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61410   Dali::Property::Map *arg2 = 0 ;
61411
61412   arg1 = (Dali::Toolkit::Builder *)jarg1;
61413   arg2 = (Dali::Property::Map *)jarg2;
61414   if (!arg2) {
61415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61416     return ;
61417   }
61418   {
61419     try {
61420       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61421     } catch (std::out_of_range& e) {
61422       {
61423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61424       };
61425     } catch (std::exception& e) {
61426       {
61427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61428       };
61429     } catch (Dali::DaliException e) {
61430       {
61431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61432       };
61433     } catch (...) {
61434       {
61435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61436       };
61437     }
61438   }
61439
61440 }
61441
61442
61443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61444   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61445   std::string *arg2 = 0 ;
61446   Dali::Property::Value *arg3 = 0 ;
61447
61448   arg1 = (Dali::Toolkit::Builder *)jarg1;
61449   if (!jarg2) {
61450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61451     return ;
61452   }
61453   std::string arg2_str(jarg2);
61454   arg2 = &arg2_str;
61455   arg3 = (Dali::Property::Value *)jarg3;
61456   if (!arg3) {
61457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61458     return ;
61459   }
61460   {
61461     try {
61462       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61463     } catch (std::out_of_range& e) {
61464       {
61465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61466       };
61467     } catch (std::exception& e) {
61468       {
61469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61470       };
61471     } catch (Dali::DaliException e) {
61472       {
61473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61474       };
61475     } catch (...) {
61476       {
61477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61478       };
61479     }
61480   }
61481
61482
61483   //argout typemap for const std::string&
61484
61485 }
61486
61487
61488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61489   void * jresult ;
61490   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61491   Dali::Property::Map *result = 0 ;
61492
61493   arg1 = (Dali::Toolkit::Builder *)jarg1;
61494   {
61495     try {
61496       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61497     } catch (std::out_of_range& e) {
61498       {
61499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61500       };
61501     } catch (std::exception& e) {
61502       {
61503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61504       };
61505     } catch (Dali::DaliException e) {
61506       {
61507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61508       };
61509     } catch (...) {
61510       {
61511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61512       };
61513     }
61514   }
61515
61516   jresult = (void *)result;
61517   return jresult;
61518 }
61519
61520
61521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61522   void * jresult ;
61523   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61524   std::string *arg2 = 0 ;
61525   Dali::Property::Value *result = 0 ;
61526
61527   arg1 = (Dali::Toolkit::Builder *)jarg1;
61528   if (!jarg2) {
61529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61530     return 0;
61531   }
61532   std::string arg2_str(jarg2);
61533   arg2 = &arg2_str;
61534   {
61535     try {
61536       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61537     } catch (std::out_of_range& e) {
61538       {
61539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61540       };
61541     } catch (std::exception& e) {
61542       {
61543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61544       };
61545     } catch (Dali::DaliException e) {
61546       {
61547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61548       };
61549     } catch (...) {
61550       {
61551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61552       };
61553     }
61554   }
61555
61556   jresult = (void *)result;
61557
61558   //argout typemap for const std::string&
61559
61560   return jresult;
61561 }
61562
61563
61564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61565   void * jresult ;
61566   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61567   std::string *arg2 = 0 ;
61568   Dali::Animation result;
61569
61570   arg1 = (Dali::Toolkit::Builder *)jarg1;
61571   if (!jarg2) {
61572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61573     return 0;
61574   }
61575   std::string arg2_str(jarg2);
61576   arg2 = &arg2_str;
61577   {
61578     try {
61579       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61580     } catch (std::out_of_range& e) {
61581       {
61582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61583       };
61584     } catch (std::exception& e) {
61585       {
61586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61587       };
61588     } catch (Dali::DaliException e) {
61589       {
61590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61591       };
61592     } catch (...) {
61593       {
61594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61595       };
61596     }
61597   }
61598
61599   jresult = new Dali::Animation((const Dali::Animation &)result);
61600
61601   //argout typemap for const std::string&
61602
61603   return jresult;
61604 }
61605
61606
61607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61608   void * jresult ;
61609   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61610   std::string *arg2 = 0 ;
61611   Dali::Property::Map *arg3 = 0 ;
61612   Dali::Animation result;
61613
61614   arg1 = (Dali::Toolkit::Builder *)jarg1;
61615   if (!jarg2) {
61616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61617     return 0;
61618   }
61619   std::string arg2_str(jarg2);
61620   arg2 = &arg2_str;
61621   arg3 = (Dali::Property::Map *)jarg3;
61622   if (!arg3) {
61623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61624     return 0;
61625   }
61626   {
61627     try {
61628       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61629     } catch (std::out_of_range& e) {
61630       {
61631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61632       };
61633     } catch (std::exception& e) {
61634       {
61635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61636       };
61637     } catch (Dali::DaliException e) {
61638       {
61639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61640       };
61641     } catch (...) {
61642       {
61643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61644       };
61645     }
61646   }
61647
61648   jresult = new Dali::Animation((const Dali::Animation &)result);
61649
61650   //argout typemap for const std::string&
61651
61652   return jresult;
61653 }
61654
61655
61656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
61657   void * jresult ;
61658   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61659   std::string *arg2 = 0 ;
61660   Dali::Actor arg3 ;
61661   Dali::Actor *argp3 ;
61662   Dali::Animation result;
61663
61664   arg1 = (Dali::Toolkit::Builder *)jarg1;
61665   if (!jarg2) {
61666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61667     return 0;
61668   }
61669   std::string arg2_str(jarg2);
61670   arg2 = &arg2_str;
61671   argp3 = (Dali::Actor *)jarg3;
61672   if (!argp3) {
61673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61674     return 0;
61675   }
61676   arg3 = *argp3;
61677   {
61678     try {
61679       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
61680     } catch (std::out_of_range& e) {
61681       {
61682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61683       };
61684     } catch (std::exception& e) {
61685       {
61686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61687       };
61688     } catch (Dali::DaliException e) {
61689       {
61690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61691       };
61692     } catch (...) {
61693       {
61694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61695       };
61696     }
61697   }
61698
61699   jresult = new Dali::Animation((const Dali::Animation &)result);
61700
61701   //argout typemap for const std::string&
61702
61703   return jresult;
61704 }
61705
61706
61707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
61708   void * jresult ;
61709   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61710   std::string *arg2 = 0 ;
61711   Dali::Property::Map *arg3 = 0 ;
61712   Dali::Actor arg4 ;
61713   Dali::Actor *argp4 ;
61714   Dali::Animation result;
61715
61716   arg1 = (Dali::Toolkit::Builder *)jarg1;
61717   if (!jarg2) {
61718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61719     return 0;
61720   }
61721   std::string arg2_str(jarg2);
61722   arg2 = &arg2_str;
61723   arg3 = (Dali::Property::Map *)jarg3;
61724   if (!arg3) {
61725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61726     return 0;
61727   }
61728   argp4 = (Dali::Actor *)jarg4;
61729   if (!argp4) {
61730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61731     return 0;
61732   }
61733   arg4 = *argp4;
61734   {
61735     try {
61736       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
61737     } catch (std::out_of_range& e) {
61738       {
61739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61740       };
61741     } catch (std::exception& e) {
61742       {
61743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61744       };
61745     } catch (Dali::DaliException e) {
61746       {
61747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61748       };
61749     } catch (...) {
61750       {
61751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61752       };
61753     }
61754   }
61755
61756   jresult = new Dali::Animation((const Dali::Animation &)result);
61757
61758   //argout typemap for const std::string&
61759
61760   return jresult;
61761 }
61762
61763
61764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
61765   void * jresult ;
61766   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61767   std::string *arg2 = 0 ;
61768   Dali::BaseHandle result;
61769
61770   arg1 = (Dali::Toolkit::Builder *)jarg1;
61771   if (!jarg2) {
61772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61773     return 0;
61774   }
61775   std::string arg2_str(jarg2);
61776   arg2 = &arg2_str;
61777   {
61778     try {
61779       result = (arg1)->Create((std::string const &)*arg2);
61780     } catch (std::out_of_range& e) {
61781       {
61782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61783       };
61784     } catch (std::exception& e) {
61785       {
61786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61787       };
61788     } catch (Dali::DaliException e) {
61789       {
61790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61791       };
61792     } catch (...) {
61793       {
61794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61795       };
61796     }
61797   }
61798
61799   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61800
61801   //argout typemap for const std::string&
61802
61803   return jresult;
61804 }
61805
61806
61807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61808   void * jresult ;
61809   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61810   std::string *arg2 = 0 ;
61811   Dali::Property::Map *arg3 = 0 ;
61812   Dali::BaseHandle result;
61813
61814   arg1 = (Dali::Toolkit::Builder *)jarg1;
61815   if (!jarg2) {
61816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61817     return 0;
61818   }
61819   std::string arg2_str(jarg2);
61820   arg2 = &arg2_str;
61821   arg3 = (Dali::Property::Map *)jarg3;
61822   if (!arg3) {
61823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61824     return 0;
61825   }
61826   {
61827     try {
61828       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61829     } catch (std::out_of_range& e) {
61830       {
61831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61832       };
61833     } catch (std::exception& e) {
61834       {
61835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61836       };
61837     } catch (Dali::DaliException e) {
61838       {
61839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61840       };
61841     } catch (...) {
61842       {
61843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61844       };
61845     }
61846   }
61847
61848   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61849
61850   //argout typemap for const std::string&
61851
61852   return jresult;
61853 }
61854
61855
61856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
61857   void * jresult ;
61858   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61859   std::string *arg2 = 0 ;
61860   Dali::BaseHandle result;
61861
61862   arg1 = (Dali::Toolkit::Builder *)jarg1;
61863   if (!jarg2) {
61864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61865     return 0;
61866   }
61867   std::string arg2_str(jarg2);
61868   arg2 = &arg2_str;
61869   {
61870     try {
61871       result = (arg1)->CreateFromJson((std::string const &)*arg2);
61872     } catch (std::out_of_range& e) {
61873       {
61874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61875       };
61876     } catch (std::exception& e) {
61877       {
61878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61879       };
61880     } catch (Dali::DaliException e) {
61881       {
61882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61883       };
61884     } catch (...) {
61885       {
61886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61887       };
61888     }
61889   }
61890
61891   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61892
61893   //argout typemap for const std::string&
61894
61895   return jresult;
61896 }
61897
61898
61899 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
61900   unsigned int jresult ;
61901   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61902   std::string *arg2 = 0 ;
61903   Dali::Handle *arg3 = 0 ;
61904   bool result;
61905
61906   arg1 = (Dali::Toolkit::Builder *)jarg1;
61907   if (!jarg2) {
61908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61909     return 0;
61910   }
61911   std::string arg2_str(jarg2);
61912   arg2 = &arg2_str;
61913   arg3 = (Dali::Handle *)jarg3;
61914   if (!arg3) {
61915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61916     return 0;
61917   }
61918   {
61919     try {
61920       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
61921     } catch (std::out_of_range& e) {
61922       {
61923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61924       };
61925     } catch (std::exception& e) {
61926       {
61927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61928       };
61929     } catch (Dali::DaliException e) {
61930       {
61931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61932       };
61933     } catch (...) {
61934       {
61935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61936       };
61937     }
61938   }
61939
61940   jresult = result;
61941
61942   //argout typemap for const std::string&
61943
61944   return jresult;
61945 }
61946
61947
61948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
61949   unsigned int jresult ;
61950   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61951   Dali::Handle *arg2 = 0 ;
61952   std::string *arg3 = 0 ;
61953   bool result;
61954
61955   arg1 = (Dali::Toolkit::Builder *)jarg1;
61956   arg2 = (Dali::Handle *)jarg2;
61957   if (!arg2) {
61958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61959     return 0;
61960   }
61961   if (!jarg3) {
61962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61963     return 0;
61964   }
61965   std::string arg3_str(jarg3);
61966   arg3 = &arg3_str;
61967   {
61968     try {
61969       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
61970     } catch (std::out_of_range& e) {
61971       {
61972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61973       };
61974     } catch (std::exception& e) {
61975       {
61976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61977       };
61978     } catch (Dali::DaliException e) {
61979       {
61980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61981       };
61982     } catch (...) {
61983       {
61984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61985       };
61986     }
61987   }
61988
61989   jresult = result;
61990
61991   //argout typemap for const std::string&
61992
61993   return jresult;
61994 }
61995
61996
61997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
61998   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61999   Dali::Actor arg2 ;
62000   Dali::Actor *argp2 ;
62001
62002   arg1 = (Dali::Toolkit::Builder *)jarg1;
62003   argp2 = (Dali::Actor *)jarg2;
62004   if (!argp2) {
62005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62006     return ;
62007   }
62008   arg2 = *argp2;
62009   {
62010     try {
62011       (arg1)->AddActors(arg2);
62012     } catch (std::out_of_range& e) {
62013       {
62014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62015       };
62016     } catch (std::exception& e) {
62017       {
62018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62019       };
62020     } catch (Dali::DaliException e) {
62021       {
62022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62023       };
62024     } catch (...) {
62025       {
62026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62027       };
62028     }
62029   }
62030
62031 }
62032
62033
62034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62035   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62036   std::string *arg2 = 0 ;
62037   Dali::Actor arg3 ;
62038   Dali::Actor *argp3 ;
62039
62040   arg1 = (Dali::Toolkit::Builder *)jarg1;
62041   if (!jarg2) {
62042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62043     return ;
62044   }
62045   std::string arg2_str(jarg2);
62046   arg2 = &arg2_str;
62047   argp3 = (Dali::Actor *)jarg3;
62048   if (!argp3) {
62049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62050     return ;
62051   }
62052   arg3 = *argp3;
62053   {
62054     try {
62055       (arg1)->AddActors((std::string const &)*arg2,arg3);
62056     } catch (std::out_of_range& e) {
62057       {
62058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62059       };
62060     } catch (std::exception& e) {
62061       {
62062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62063       };
62064     } catch (Dali::DaliException e) {
62065       {
62066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62067       };
62068     } catch (...) {
62069       {
62070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62071       };
62072     }
62073   }
62074
62075
62076   //argout typemap for const std::string&
62077
62078 }
62079
62080
62081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62082   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62083   std::string *arg2 = 0 ;
62084
62085   arg1 = (Dali::Toolkit::Builder *)jarg1;
62086   if (!jarg2) {
62087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62088     return ;
62089   }
62090   std::string arg2_str(jarg2);
62091   arg2 = &arg2_str;
62092   {
62093     try {
62094       (arg1)->CreateRenderTask((std::string const &)*arg2);
62095     } catch (std::out_of_range& e) {
62096       {
62097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62098       };
62099     } catch (std::exception& e) {
62100       {
62101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62102       };
62103     } catch (Dali::DaliException e) {
62104       {
62105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62106       };
62107     } catch (...) {
62108       {
62109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62110       };
62111     }
62112   }
62113
62114
62115   //argout typemap for const std::string&
62116
62117 }
62118
62119
62120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62121   void * jresult ;
62122   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62123   std::string *arg2 = 0 ;
62124   Dali::Path result;
62125
62126   arg1 = (Dali::Toolkit::Builder *)jarg1;
62127   if (!jarg2) {
62128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62129     return 0;
62130   }
62131   std::string arg2_str(jarg2);
62132   arg2 = &arg2_str;
62133   {
62134     try {
62135       result = (arg1)->GetPath((std::string const &)*arg2);
62136     } catch (std::out_of_range& e) {
62137       {
62138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62139       };
62140     } catch (std::exception& e) {
62141       {
62142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62143       };
62144     } catch (Dali::DaliException e) {
62145       {
62146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62147       };
62148     } catch (...) {
62149       {
62150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62151       };
62152     }
62153   }
62154
62155   jresult = new Dali::Path((const Dali::Path &)result);
62156
62157   //argout typemap for const std::string&
62158
62159   return jresult;
62160 }
62161
62162
62163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62164   void * jresult ;
62165   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62166   std::string *arg2 = 0 ;
62167   Dali::PathConstrainer result;
62168
62169   arg1 = (Dali::Toolkit::Builder *)jarg1;
62170   if (!jarg2) {
62171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62172     return 0;
62173   }
62174   std::string arg2_str(jarg2);
62175   arg2 = &arg2_str;
62176   {
62177     try {
62178       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62179     } catch (std::out_of_range& e) {
62180       {
62181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62182       };
62183     } catch (std::exception& e) {
62184       {
62185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62186       };
62187     } catch (Dali::DaliException e) {
62188       {
62189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62190       };
62191     } catch (...) {
62192       {
62193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62194       };
62195     }
62196   }
62197
62198   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62199
62200   //argout typemap for const std::string&
62201
62202   return jresult;
62203 }
62204
62205
62206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62207   void * jresult ;
62208   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62209   std::string *arg2 = 0 ;
62210   Dali::LinearConstrainer result;
62211
62212   arg1 = (Dali::Toolkit::Builder *)jarg1;
62213   if (!jarg2) {
62214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62215     return 0;
62216   }
62217   std::string arg2_str(jarg2);
62218   arg2 = &arg2_str;
62219   {
62220     try {
62221       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62222     } catch (std::out_of_range& e) {
62223       {
62224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62225       };
62226     } catch (std::exception& e) {
62227       {
62228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62229       };
62230     } catch (Dali::DaliException e) {
62231       {
62232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62233       };
62234     } catch (...) {
62235       {
62236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62237       };
62238     }
62239   }
62240
62241   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62242
62243   //argout typemap for const std::string&
62244
62245   return jresult;
62246 }
62247
62248
62249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62250   void * jresult ;
62251   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62252   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62253
62254   arg1 = (Dali::Toolkit::Builder *)jarg1;
62255   {
62256     try {
62257       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62258     } catch (std::out_of_range& e) {
62259       {
62260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62261       };
62262     } catch (std::exception& e) {
62263       {
62264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62265       };
62266     } catch (Dali::DaliException e) {
62267       {
62268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62269       };
62270     } catch (...) {
62271       {
62272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62273       };
62274     }
62275   }
62276
62277   jresult = (void *)result;
62278   return jresult;
62279 }
62280
62281
62282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62283   void * jresult ;
62284   Dali::Toolkit::TransitionData *result = 0 ;
62285
62286   {
62287     try {
62288       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62289     } catch (std::out_of_range& e) {
62290       {
62291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62292       };
62293     } catch (std::exception& e) {
62294       {
62295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62296       };
62297     } catch (Dali::DaliException e) {
62298       {
62299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62300       };
62301     } catch (...) {
62302       {
62303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62304       };
62305     }
62306   }
62307
62308   jresult = (void *)result;
62309   return jresult;
62310 }
62311
62312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62313   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62314
62315   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62316   {
62317     try {
62318       delete arg1;
62319     } catch (std::out_of_range& e) {
62320       {
62321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62322       };
62323     } catch (std::exception& e) {
62324       {
62325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62326       };
62327     } catch (Dali::DaliException e) {
62328       {
62329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62330       };
62331     } catch (...) {
62332       {
62333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62334       };
62335     }
62336   }
62337
62338 }
62339
62340
62341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62342   void * jresult ;
62343   Dali::Property::Map *arg1 = 0 ;
62344   Dali::Toolkit::TransitionData result;
62345
62346   arg1 = (Dali::Property::Map *)jarg1;
62347   if (!arg1) {
62348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62349     return 0;
62350   }
62351   {
62352     try {
62353       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62354     } catch (std::out_of_range& e) {
62355       {
62356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62357       };
62358     } catch (std::exception& e) {
62359       {
62360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62361       };
62362     } catch (Dali::DaliException e) {
62363       {
62364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62365       };
62366     } catch (...) {
62367       {
62368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62369       };
62370     }
62371   }
62372
62373   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62374   return jresult;
62375 }
62376
62377
62378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62379   void * jresult ;
62380   Dali::Property::Array *arg1 = 0 ;
62381   Dali::Toolkit::TransitionData result;
62382
62383   arg1 = (Dali::Property::Array *)jarg1;
62384   if (!arg1) {
62385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62386     return 0;
62387   }
62388   {
62389     try {
62390       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62391     } catch (std::out_of_range& e) {
62392       {
62393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62394       };
62395     } catch (std::exception& e) {
62396       {
62397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62398       };
62399     } catch (Dali::DaliException e) {
62400       {
62401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62402       };
62403     } catch (...) {
62404       {
62405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62406       };
62407     }
62408   }
62409
62410   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62411   return jresult;
62412 }
62413
62414
62415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62416   void * jresult ;
62417   Dali::BaseHandle arg1 ;
62418   Dali::BaseHandle *argp1 ;
62419   Dali::Toolkit::TransitionData result;
62420
62421   argp1 = (Dali::BaseHandle *)jarg1;
62422   if (!argp1) {
62423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62424     return 0;
62425   }
62426   arg1 = *argp1;
62427   {
62428     try {
62429       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62430     } catch (std::out_of_range& e) {
62431       {
62432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62433       };
62434     } catch (std::exception& e) {
62435       {
62436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62437       };
62438     } catch (Dali::DaliException e) {
62439       {
62440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62441       };
62442     } catch (...) {
62443       {
62444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62445       };
62446     }
62447   }
62448
62449   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62450   return jresult;
62451 }
62452
62453
62454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62455   void * jresult ;
62456   Dali::Toolkit::TransitionData *arg1 = 0 ;
62457   Dali::Toolkit::TransitionData *result = 0 ;
62458
62459   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62460   if (!arg1) {
62461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62462     return 0;
62463   }
62464   {
62465     try {
62466       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62467     } catch (std::out_of_range& e) {
62468       {
62469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62470       };
62471     } catch (std::exception& e) {
62472       {
62473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62474       };
62475     } catch (Dali::DaliException e) {
62476       {
62477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62478       };
62479     } catch (...) {
62480       {
62481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62482       };
62483     }
62484   }
62485
62486   jresult = (void *)result;
62487   return jresult;
62488 }
62489
62490
62491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62492   void * jresult ;
62493   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62494   Dali::Toolkit::TransitionData *arg2 = 0 ;
62495   Dali::Toolkit::TransitionData *result = 0 ;
62496
62497   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62498   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62499   if (!arg2) {
62500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62501     return 0;
62502   }
62503   {
62504     try {
62505       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62506     } catch (std::out_of_range& e) {
62507       {
62508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62509       };
62510     } catch (std::exception& e) {
62511       {
62512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62513       };
62514     } catch (Dali::DaliException e) {
62515       {
62516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62517       };
62518     } catch (...) {
62519       {
62520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62521       };
62522     }
62523   }
62524
62525   jresult = (void *)result;
62526   return jresult;
62527 }
62528
62529
62530 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62531   unsigned long jresult ;
62532   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62533   size_t result;
62534
62535   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62536   {
62537     try {
62538       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62539     } catch (std::out_of_range& e) {
62540       {
62541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62542       };
62543     } catch (std::exception& e) {
62544       {
62545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62546       };
62547     } catch (Dali::DaliException e) {
62548       {
62549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62550       };
62551     } catch (...) {
62552       {
62553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62554       };
62555     }
62556   }
62557
62558   jresult = (unsigned long)result;
62559   return jresult;
62560 }
62561
62562
62563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62564   void * jresult ;
62565   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62566   size_t arg2 ;
62567   Dali::Property::Map result;
62568
62569   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62570   arg2 = (size_t)jarg2;
62571   {
62572     try {
62573       result = (arg1)->GetAnimatorAt(arg2);
62574     } catch (std::out_of_range& e) {
62575       {
62576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62577       };
62578     } catch (std::exception& e) {
62579       {
62580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62581       };
62582     } catch (Dali::DaliException e) {
62583       {
62584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62585       };
62586     } catch (...) {
62587       {
62588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62589       };
62590     }
62591   }
62592
62593   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62594   return jresult;
62595 }
62596
62597
62598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62599   int jresult ;
62600   int result;
62601
62602   {
62603     try {
62604       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62605     } catch (std::out_of_range& e) {
62606       {
62607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62608       };
62609     } catch (std::exception& e) {
62610       {
62611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62612       };
62613     } catch (Dali::DaliException e) {
62614       {
62615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62616       };
62617     } catch (...) {
62618       {
62619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62620       };
62621     }
62622   }
62623
62624   jresult = (int)result;
62625   return jresult;
62626 }
62627
62628
62629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62630   int jresult ;
62631   int result;
62632
62633   {
62634     try {
62635       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
62636     } catch (std::out_of_range& e) {
62637       {
62638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62639       };
62640     } catch (std::exception& e) {
62641       {
62642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62643       };
62644     } catch (Dali::DaliException e) {
62645       {
62646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62647       };
62648     } catch (...) {
62649       {
62650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62651       };
62652     }
62653   }
62654
62655   jresult = (int)result;
62656   return jresult;
62657 }
62658
62659
62660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
62661   int jresult ;
62662   int result;
62663
62664   {
62665     try {
62666       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
62667     } catch (std::out_of_range& e) {
62668       {
62669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62670       };
62671     } catch (std::exception& e) {
62672       {
62673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62674       };
62675     } catch (Dali::DaliException e) {
62676       {
62677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62678       };
62679     } catch (...) {
62680       {
62681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62682       };
62683     }
62684   }
62685
62686   jresult = (int)result;
62687   return jresult;
62688 }
62689
62690
62691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
62692   int jresult ;
62693   int result;
62694
62695   {
62696     try {
62697       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
62698     } catch (std::out_of_range& e) {
62699       {
62700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62701       };
62702     } catch (std::exception& e) {
62703       {
62704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62705       };
62706     } catch (Dali::DaliException e) {
62707       {
62708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62709       };
62710     } catch (...) {
62711       {
62712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62713       };
62714     }
62715   }
62716
62717   jresult = (int)result;
62718   return jresult;
62719 }
62720
62721
62722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
62723   int jresult ;
62724   int result;
62725
62726   {
62727     try {
62728       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
62729     } catch (std::out_of_range& e) {
62730       {
62731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62732       };
62733     } catch (std::exception& e) {
62734       {
62735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62736       };
62737     } catch (Dali::DaliException e) {
62738       {
62739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62740       };
62741     } catch (...) {
62742       {
62743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62744       };
62745     }
62746   }
62747
62748   jresult = (int)result;
62749   return jresult;
62750 }
62751
62752
62753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
62754   int jresult ;
62755   int result;
62756
62757   {
62758     try {
62759       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
62760     } catch (std::out_of_range& e) {
62761       {
62762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62763       };
62764     } catch (std::exception& e) {
62765       {
62766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62767       };
62768     } catch (Dali::DaliException e) {
62769       {
62770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62771       };
62772     } catch (...) {
62773       {
62774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62775       };
62776     }
62777   }
62778
62779   jresult = (int)result;
62780   return jresult;
62781 }
62782
62783
62784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
62785   int jresult ;
62786   int result;
62787
62788   {
62789     try {
62790       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
62791     } catch (std::out_of_range& e) {
62792       {
62793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62794       };
62795     } catch (std::exception& e) {
62796       {
62797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62798       };
62799     } catch (Dali::DaliException e) {
62800       {
62801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62802       };
62803     } catch (...) {
62804       {
62805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62806       };
62807     }
62808   }
62809
62810   jresult = (int)result;
62811   return jresult;
62812 }
62813
62814
62815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
62816   int jresult ;
62817   int result;
62818
62819   {
62820     try {
62821       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
62822     } catch (std::out_of_range& e) {
62823       {
62824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62825       };
62826     } catch (std::exception& e) {
62827       {
62828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62829       };
62830     } catch (Dali::DaliException e) {
62831       {
62832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62833       };
62834     } catch (...) {
62835       {
62836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62837       };
62838     }
62839   }
62840
62841   jresult = (int)result;
62842   return jresult;
62843 }
62844
62845
62846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
62847   int jresult ;
62848   int result;
62849
62850   {
62851     try {
62852       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
62853     } catch (std::out_of_range& e) {
62854       {
62855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62856       };
62857     } catch (std::exception& e) {
62858       {
62859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62860       };
62861     } catch (Dali::DaliException e) {
62862       {
62863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62864       };
62865     } catch (...) {
62866       {
62867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62868       };
62869     }
62870   }
62871
62872   jresult = (int)result;
62873   return jresult;
62874 }
62875
62876
62877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
62878   int jresult ;
62879   int result;
62880
62881   {
62882     try {
62883       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
62884     } catch (std::out_of_range& e) {
62885       {
62886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62887       };
62888     } catch (std::exception& e) {
62889       {
62890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62891       };
62892     } catch (Dali::DaliException e) {
62893       {
62894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62895       };
62896     } catch (...) {
62897       {
62898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62899       };
62900     }
62901   }
62902
62903   jresult = (int)result;
62904   return jresult;
62905 }
62906
62907
62908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
62909   int jresult ;
62910   int result;
62911
62912   {
62913     try {
62914       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
62915     } catch (std::out_of_range& e) {
62916       {
62917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62918       };
62919     } catch (std::exception& e) {
62920       {
62921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62922       };
62923     } catch (Dali::DaliException e) {
62924       {
62925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62926       };
62927     } catch (...) {
62928       {
62929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62930       };
62931     }
62932   }
62933
62934   jresult = (int)result;
62935   return jresult;
62936 }
62937
62938
62939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
62940   int jresult ;
62941   int result;
62942
62943   {
62944     try {
62945       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
62946     } catch (std::out_of_range& e) {
62947       {
62948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62949       };
62950     } catch (std::exception& e) {
62951       {
62952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62953       };
62954     } catch (Dali::DaliException e) {
62955       {
62956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62957       };
62958     } catch (...) {
62959       {
62960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62961       };
62962     }
62963   }
62964
62965   jresult = (int)result;
62966   return jresult;
62967 }
62968
62969
62970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
62971   int jresult ;
62972   int result;
62973
62974   {
62975     try {
62976       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
62977     } catch (std::out_of_range& e) {
62978       {
62979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62980       };
62981     } catch (std::exception& e) {
62982       {
62983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62984       };
62985     } catch (Dali::DaliException e) {
62986       {
62987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62988       };
62989     } catch (...) {
62990       {
62991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62992       };
62993     }
62994   }
62995
62996   jresult = (int)result;
62997   return jresult;
62998 }
62999
63000
63001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
63002   int jresult ;
63003   int result;
63004
63005   {
63006     try {
63007       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
63008     } catch (std::out_of_range& e) {
63009       {
63010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63011       };
63012     } catch (std::exception& e) {
63013       {
63014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63015       };
63016     } catch (Dali::DaliException e) {
63017       {
63018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63019       };
63020     } catch (...) {
63021       {
63022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63023       };
63024     }
63025   }
63026
63027   jresult = (int)result;
63028   return jresult;
63029 }
63030
63031
63032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
63033   void * jresult ;
63034   Dali::Toolkit::Control result;
63035
63036   {
63037     try {
63038       result = Dali::Toolkit::Internal::Control::New();
63039     } catch (std::out_of_range& e) {
63040       {
63041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63042       };
63043     } catch (std::exception& e) {
63044       {
63045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63046       };
63047     } catch (Dali::DaliException e) {
63048       {
63049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63050       };
63051     } catch (...) {
63052       {
63053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63054       };
63055     }
63056   }
63057
63058   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63059   return jresult;
63060 }
63061
63062
63063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
63064   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63065   std::string *arg2 = 0 ;
63066
63067   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63068   if (!jarg2) {
63069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63070     return ;
63071   }
63072   std::string arg2_str(jarg2);
63073   arg2 = &arg2_str;
63074   {
63075     try {
63076       (arg1)->SetStyleName((std::string const &)*arg2);
63077     } catch (std::out_of_range& e) {
63078       {
63079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63080       };
63081     } catch (std::exception& e) {
63082       {
63083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63084       };
63085     } catch (Dali::DaliException e) {
63086       {
63087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63088       };
63089     } catch (...) {
63090       {
63091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63092       };
63093     }
63094   }
63095
63096
63097   //argout typemap for const std::string&
63098
63099 }
63100
63101
63102 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63103   char * jresult ;
63104   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63105   std::string *result = 0 ;
63106
63107   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63108   {
63109     try {
63110       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63111     } catch (std::out_of_range& e) {
63112       {
63113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63114       };
63115     } catch (std::exception& e) {
63116       {
63117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63118       };
63119     } catch (Dali::DaliException e) {
63120       {
63121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63122       };
63123     } catch (...) {
63124       {
63125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63126       };
63127     }
63128   }
63129
63130   jresult = SWIG_csharp_string_callback(result->c_str());
63131   return jresult;
63132 }
63133
63134
63135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63136   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63137   Dali::Vector4 *arg2 = 0 ;
63138
63139   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63140   arg2 = (Dali::Vector4 *)jarg2;
63141   if (!arg2) {
63142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63143     return ;
63144   }
63145   {
63146     try {
63147       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63148     } catch (std::out_of_range& e) {
63149       {
63150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63151       };
63152     } catch (std::exception& e) {
63153       {
63154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63155       };
63156     } catch (Dali::DaliException e) {
63157       {
63158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63159       };
63160     } catch (...) {
63161       {
63162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63163       };
63164     }
63165   }
63166
63167 }
63168
63169
63170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63171   void * jresult ;
63172   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
63173   Dali::Vector4 result;
63174
63175   arg1 = (Dali::Handle *)jarg1;
63176   {
63177     try {
63178       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
63179       if (resultMap)
63180       {
63181         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
63182         if(type && type->Get<int>() == Visual::COLOR )
63183         {
63184           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
63185           if (value)
63186           {
63187             result = value->Get<Vector4>();
63188           }
63189         }
63190       }
63191     } catch (std::out_of_range& e) {
63192       {
63193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63194       };
63195     } catch (std::exception& e) {
63196       {
63197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63198       };
63199     } catch (Dali::DaliException e) {
63200       {
63201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63202       };
63203     } catch (...) {
63204       {
63205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63206       };
63207     }
63208   }
63209
63210   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63211   return jresult;
63212 }
63213
63214
63215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63216   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63217   Dali::Property::Map *arg2 = 0 ;
63218
63219   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63220   arg2 = (Dali::Property::Map *)jarg2;
63221   if (!arg2) {
63222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63223     return ;
63224   }
63225   {
63226     try {
63227       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63228     } catch (std::out_of_range& e) {
63229       {
63230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63231       };
63232     } catch (std::exception& e) {
63233       {
63234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63235       };
63236     } catch (Dali::DaliException e) {
63237       {
63238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63239       };
63240     } catch (...) {
63241       {
63242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63243       };
63244     }
63245   }
63246
63247 }
63248
63249
63250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63251   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63252
63253   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63254   {
63255     try {
63256       (arg1)->ClearBackground();
63257     } catch (std::out_of_range& e) {
63258       {
63259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63260       };
63261     } catch (std::exception& e) {
63262       {
63263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63264       };
63265     } catch (Dali::DaliException e) {
63266       {
63267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63268       };
63269     } catch (...) {
63270       {
63271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63272       };
63273     }
63274   }
63275
63276 }
63277
63278
63279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63280   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63281   Dali::Gesture::Type arg2 ;
63282
63283   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63284   arg2 = (Dali::Gesture::Type)jarg2;
63285   {
63286     try {
63287       (arg1)->EnableGestureDetection(arg2);
63288     } catch (std::out_of_range& e) {
63289       {
63290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63291       };
63292     } catch (std::exception& e) {
63293       {
63294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63295       };
63296     } catch (Dali::DaliException e) {
63297       {
63298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63299       };
63300     } catch (...) {
63301       {
63302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63303       };
63304     }
63305   }
63306
63307 }
63308
63309
63310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63311   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63312   Dali::Gesture::Type arg2 ;
63313
63314   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63315   arg2 = (Dali::Gesture::Type)jarg2;
63316   {
63317     try {
63318       (arg1)->DisableGestureDetection(arg2);
63319     } catch (std::out_of_range& e) {
63320       {
63321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63322       };
63323     } catch (std::exception& e) {
63324       {
63325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63326       };
63327     } catch (Dali::DaliException e) {
63328       {
63329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63330       };
63331     } catch (...) {
63332       {
63333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63334       };
63335     }
63336   }
63337
63338 }
63339
63340
63341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63342   void * jresult ;
63343   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63344   Dali::PinchGestureDetector result;
63345
63346   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63347   {
63348     try {
63349       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63350     } catch (std::out_of_range& e) {
63351       {
63352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63353       };
63354     } catch (std::exception& e) {
63355       {
63356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63357       };
63358     } catch (Dali::DaliException e) {
63359       {
63360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63361       };
63362     } catch (...) {
63363       {
63364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63365       };
63366     }
63367   }
63368
63369   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63370   return jresult;
63371 }
63372
63373
63374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63375   void * jresult ;
63376   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63377   Dali::PanGestureDetector result;
63378
63379   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63380   {
63381     try {
63382       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63383     } catch (std::out_of_range& e) {
63384       {
63385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63386       };
63387     } catch (std::exception& e) {
63388       {
63389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63390       };
63391     } catch (Dali::DaliException e) {
63392       {
63393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63394       };
63395     } catch (...) {
63396       {
63397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63398       };
63399     }
63400   }
63401
63402   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63403   return jresult;
63404 }
63405
63406
63407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63408   void * jresult ;
63409   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63410   Dali::TapGestureDetector result;
63411
63412   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63413   {
63414     try {
63415       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63416     } catch (std::out_of_range& e) {
63417       {
63418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63419       };
63420     } catch (std::exception& e) {
63421       {
63422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63423       };
63424     } catch (Dali::DaliException e) {
63425       {
63426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63427       };
63428     } catch (...) {
63429       {
63430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63431       };
63432     }
63433   }
63434
63435   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63436   return jresult;
63437 }
63438
63439
63440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63441   void * jresult ;
63442   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63443   Dali::LongPressGestureDetector result;
63444
63445   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63446   {
63447     try {
63448       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63449     } catch (std::out_of_range& e) {
63450       {
63451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63452       };
63453     } catch (std::exception& e) {
63454       {
63455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63456       };
63457     } catch (Dali::DaliException e) {
63458       {
63459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63460       };
63461     } catch (...) {
63462       {
63463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63464       };
63465     }
63466   }
63467
63468   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63469   return jresult;
63470 }
63471
63472
63473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63474   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63475   bool arg2 ;
63476
63477   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63478   arg2 = jarg2 ? true : false;
63479   {
63480     try {
63481       (arg1)->SetKeyboardNavigationSupport(arg2);
63482     } catch (std::out_of_range& e) {
63483       {
63484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63485       };
63486     } catch (std::exception& e) {
63487       {
63488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63489       };
63490     } catch (Dali::DaliException e) {
63491       {
63492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63493       };
63494     } catch (...) {
63495       {
63496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63497       };
63498     }
63499   }
63500
63501 }
63502
63503
63504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63505   unsigned int jresult ;
63506   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63507   bool result;
63508
63509   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63510   {
63511     try {
63512       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63513     } catch (std::out_of_range& e) {
63514       {
63515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63516       };
63517     } catch (std::exception& e) {
63518       {
63519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63520       };
63521     } catch (Dali::DaliException e) {
63522       {
63523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63524       };
63525     } catch (...) {
63526       {
63527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63528       };
63529     }
63530   }
63531
63532   jresult = result;
63533   return jresult;
63534 }
63535
63536
63537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63538   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63539
63540   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63541   {
63542     try {
63543       (arg1)->SetKeyInputFocus();
63544     } catch (std::out_of_range& e) {
63545       {
63546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63547       };
63548     } catch (std::exception& e) {
63549       {
63550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63551       };
63552     } catch (Dali::DaliException e) {
63553       {
63554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63555       };
63556     } catch (...) {
63557       {
63558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63559       };
63560     }
63561   }
63562
63563 }
63564
63565
63566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63567   unsigned int jresult ;
63568   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63569   bool result;
63570
63571   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63572   {
63573     try {
63574       result = (bool)(arg1)->HasKeyInputFocus();
63575     } catch (std::out_of_range& e) {
63576       {
63577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63578       };
63579     } catch (std::exception& e) {
63580       {
63581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63582       };
63583     } catch (Dali::DaliException e) {
63584       {
63585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63586       };
63587     } catch (...) {
63588       {
63589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63590       };
63591     }
63592   }
63593
63594   jresult = result;
63595   return jresult;
63596 }
63597
63598
63599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
63600   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63601
63602   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63603   {
63604     try {
63605       (arg1)->ClearKeyInputFocus();
63606     } catch (std::out_of_range& e) {
63607       {
63608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63609       };
63610     } catch (std::exception& e) {
63611       {
63612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63613       };
63614     } catch (Dali::DaliException e) {
63615       {
63616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63617       };
63618     } catch (...) {
63619       {
63620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63621       };
63622     }
63623   }
63624
63625 }
63626
63627
63628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
63629   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63630   bool arg2 ;
63631
63632   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63633   arg2 = jarg2 ? true : false;
63634   {
63635     try {
63636       (arg1)->SetAsKeyboardFocusGroup(arg2);
63637     } catch (std::out_of_range& e) {
63638       {
63639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63640       };
63641     } catch (std::exception& e) {
63642       {
63643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63644       };
63645     } catch (Dali::DaliException e) {
63646       {
63647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63648       };
63649     } catch (...) {
63650       {
63651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63652       };
63653     }
63654   }
63655
63656 }
63657
63658
63659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
63660   unsigned int jresult ;
63661   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63662   bool result;
63663
63664   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63665   {
63666     try {
63667       result = (bool)(arg1)->IsKeyboardFocusGroup();
63668     } catch (std::out_of_range& e) {
63669       {
63670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63671       };
63672     } catch (std::exception& e) {
63673       {
63674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63675       };
63676     } catch (Dali::DaliException e) {
63677       {
63678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63679       };
63680     } catch (...) {
63681       {
63682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63683       };
63684     }
63685   }
63686
63687   jresult = result;
63688   return jresult;
63689 }
63690
63691
63692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
63693   void * jresult ;
63694   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63695   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63696
63697   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63698   {
63699     try {
63700       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63701     } catch (std::out_of_range& e) {
63702       {
63703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63704       };
63705     } catch (std::exception& e) {
63706       {
63707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63708       };
63709     } catch (Dali::DaliException e) {
63710       {
63711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63712       };
63713     } catch (...) {
63714       {
63715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63716       };
63717     }
63718   }
63719
63720   jresult = (void *)result;
63721   return jresult;
63722 }
63723
63724
63725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
63726   void * jresult ;
63727   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63728   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63729
63730   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63731   {
63732     try {
63733       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63734     } catch (std::out_of_range& e) {
63735       {
63736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63737       };
63738     } catch (std::exception& e) {
63739       {
63740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63741       };
63742     } catch (Dali::DaliException e) {
63743       {
63744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63745       };
63746     } catch (...) {
63747       {
63748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63749       };
63750     }
63751   }
63752
63753   jresult = (void *)result;
63754   return jresult;
63755 }
63756
63757
63758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
63759   void * jresult ;
63760   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63761   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63762
63763   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63764   {
63765     try {
63766       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63767     } catch (std::out_of_range& e) {
63768       {
63769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63770       };
63771     } catch (std::exception& e) {
63772       {
63773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63774       };
63775     } catch (Dali::DaliException e) {
63776       {
63777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63778       };
63779     } catch (...) {
63780       {
63781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63782       };
63783     }
63784   }
63785
63786   jresult = (void *)result;
63787   return jresult;
63788 }
63789
63790
63791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
63792   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63793   int arg2 ;
63794   SwigDirector_ViewImpl *darg = 0;
63795
63796   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63797   arg2 = (int)jarg2;
63798   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63799   if(!darg) {
63800     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63801     return;
63802   }
63803   {
63804     try {
63805       if(darg) {
63806         (darg)->OnStageConnection(arg2);
63807       }
63808     } catch (std::out_of_range& e) {
63809       {
63810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63811       };
63812     } catch (std::exception& e) {
63813       {
63814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63815       };
63816     } catch (Dali::DaliException e) {
63817       {
63818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63819       };
63820     } catch (...) {
63821       {
63822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63823       };
63824     }
63825   }
63826
63827 }
63828
63829
63830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
63831   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63832   int arg2 ;
63833   SwigDirector_ViewImpl *darg = 0;
63834
63835   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63836   arg2 = (int)jarg2;
63837   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63838   if(!darg) {
63839     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63840     return;
63841   }
63842   {
63843     try {
63844       if(darg) {
63845         (darg)->OnStageConnectionSwigPublic(arg2);
63846       }
63847     } catch (std::out_of_range& e) {
63848       {
63849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63850       };
63851     } catch (std::exception& e) {
63852       {
63853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63854       };
63855     } catch (Dali::DaliException e) {
63856       {
63857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63858       };
63859     } catch (...) {
63860       {
63861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63862       };
63863     }
63864   }
63865
63866 }
63867
63868
63869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
63870   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63871   SwigDirector_ViewImpl *darg = 0;
63872
63873   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63874   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63875   if(!darg) {
63876     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63877     return;
63878   }
63879   {
63880     try {
63881       if(darg) {
63882         (darg)->OnStageDisconnection();
63883       }
63884     } catch (std::out_of_range& e) {
63885       {
63886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63887       };
63888     } catch (std::exception& e) {
63889       {
63890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63891       };
63892     } catch (Dali::DaliException e) {
63893       {
63894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63895       };
63896     } catch (...) {
63897       {
63898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63899       };
63900     }
63901   }
63902
63903 }
63904
63905
63906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
63907   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63908   SwigDirector_ViewImpl *darg = 0;
63909
63910   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63911   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63912   if(!darg) {
63913     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63914     return;
63915   }
63916   {
63917     try {
63918       if(darg) {
63919         (darg)->OnStageDisconnectionSwigPublic();
63920       }
63921     } catch (std::out_of_range& e) {
63922       {
63923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63924       };
63925     } catch (std::exception& e) {
63926       {
63927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63928       };
63929     } catch (Dali::DaliException e) {
63930       {
63931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63932       };
63933     } catch (...) {
63934       {
63935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63936       };
63937     }
63938   }
63939
63940 }
63941
63942
63943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
63944   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63945   Dali::Actor *arg2 = 0 ;
63946   SwigDirector_ViewImpl *darg = 0;
63947
63948   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63949   arg2 = (Dali::Actor *)jarg2;
63950   if (!arg2) {
63951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63952     return ;
63953   }
63954   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63955   if(!darg) {
63956     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63957     return;
63958   }
63959   {
63960     try {
63961       if(darg) {
63962         (darg)->OnChildAdd(*arg2);
63963       }
63964     } catch (std::out_of_range& e) {
63965       {
63966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63967       };
63968     } catch (std::exception& e) {
63969       {
63970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63971       };
63972     } catch (Dali::DaliException e) {
63973       {
63974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63975       };
63976     } catch (...) {
63977       {
63978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63979       };
63980     }
63981   }
63982
63983 }
63984
63985
63986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63987   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63988   Dali::Actor *arg2 = 0 ;
63989   SwigDirector_ViewImpl *darg = 0;
63990
63991   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63992   arg2 = (Dali::Actor *)jarg2;
63993   if (!arg2) {
63994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63995     return ;
63996   }
63997   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63998   if(!darg) {
63999     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64000     return;
64001   }
64002   {
64003     try {
64004       if(darg) {
64005           (darg)->OnChildAddSwigPublic(*arg2);
64006       }
64007     } catch (std::out_of_range& e) {
64008       {
64009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64010       };
64011     } catch (std::exception& e) {
64012       {
64013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64014       };
64015     } catch (Dali::DaliException e) {
64016       {
64017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64018       };
64019     } catch (...) {
64020       {
64021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64022       };
64023     }
64024   }
64025
64026 }
64027
64028
64029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
64030   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64031   Dali::Actor *arg2 = 0 ;
64032   SwigDirector_ViewImpl *darg = 0;
64033
64034   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64035   arg2 = (Dali::Actor *)jarg2;
64036   if (!arg2) {
64037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64038     return ;
64039   }
64040   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64041   if(!darg) {
64042     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64043     return;
64044   }
64045   {
64046     try {
64047       if(darg) {
64048         (darg)->OnChildRemove(*arg2);
64049       }
64050     } catch (std::out_of_range& e) {
64051       {
64052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64053       };
64054     } catch (std::exception& e) {
64055       {
64056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64057       };
64058     } catch (Dali::DaliException e) {
64059       {
64060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64061       };
64062     } catch (...) {
64063       {
64064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64065       };
64066     }
64067   }
64068
64069 }
64070
64071
64072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64073   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64074   Dali::Actor *arg2 = 0 ;
64075   SwigDirector_ViewImpl *darg = 0;
64076
64077   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64078   arg2 = (Dali::Actor *)jarg2;
64079   if (!arg2) {
64080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64081     return ;
64082   }
64083   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64084   if(!darg) {
64085     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64086     return;
64087   }
64088   {
64089     try {
64090       if(darg) {
64091         (darg)->OnChildRemoveSwigPublic(*arg2);
64092       }
64093     } catch (std::out_of_range& e) {
64094       {
64095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64096       };
64097     } catch (std::exception& e) {
64098       {
64099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64100       };
64101     } catch (Dali::DaliException e) {
64102       {
64103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64104       };
64105     } catch (...) {
64106       {
64107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64108       };
64109     }
64110   }
64111
64112 }
64113
64114
64115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64116   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64117   Dali::Property::Index arg2 ;
64118   Dali::Property::Value arg3 ;
64119   Dali::Property::Value *argp3 ;
64120   SwigDirector_ViewImpl *darg = 0;
64121
64122   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64123   arg2 = (Dali::Property::Index)jarg2;
64124   argp3 = (Dali::Property::Value *)jarg3;
64125   if (!argp3) {
64126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64127     return ;
64128   }
64129   arg3 = *argp3;
64130   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64131   if (!darg) {
64132     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64133     return;
64134   }
64135   {
64136     try {
64137       (darg)->OnPropertySet(arg2,arg3);
64138     } catch (std::out_of_range& e) {
64139       {
64140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64141       };
64142     } catch (std::exception& e) {
64143       {
64144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64145       };
64146     } catch (Dali::DaliException e) {
64147       {
64148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64149       };
64150     } catch (...) {
64151       {
64152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64153       };
64154     }
64155   }
64156
64157 }
64158
64159
64160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64161   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64162   Dali::Property::Index arg2 ;
64163   Dali::Property::Value arg3 ;
64164   Dali::Property::Value *argp3 ;
64165   SwigDirector_ViewImpl *darg = 0;
64166
64167   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64168   arg2 = (Dali::Property::Index)jarg2;
64169   argp3 = (Dali::Property::Value *)jarg3;
64170   if (!argp3) {
64171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64172     return ;
64173   }
64174   arg3 = *argp3;
64175   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64176   if (!darg) {
64177     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64178     return;
64179   }
64180   {
64181     try {
64182       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64183     } catch (std::out_of_range& e) {
64184       {
64185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64186       };
64187     } catch (std::exception& e) {
64188       {
64189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64190       };
64191     } catch (Dali::DaliException e) {
64192       {
64193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64194       };
64195     } catch (...) {
64196       {
64197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64198       };
64199     }
64200   }
64201
64202 }
64203
64204
64205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64206   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64207   Dali::Vector3 *arg2 = 0 ;
64208   SwigDirector_ViewImpl *darg = 0;
64209
64210   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64211   arg2 = (Dali::Vector3 *)jarg2;
64212   if (!arg2) {
64213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64214     return ;
64215   }
64216   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64217   if (!darg) {
64218     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64219     return;
64220   }
64221   {
64222     try {
64223       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64224     } catch (std::out_of_range& e) {
64225       {
64226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64227       };
64228     } catch (std::exception& e) {
64229       {
64230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64231       };
64232     } catch (Dali::DaliException e) {
64233       {
64234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64235       };
64236     } catch (...) {
64237       {
64238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64239       };
64240     }
64241   }
64242
64243 }
64244
64245
64246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64247   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64248   Dali::Vector3 *arg2 = 0 ;
64249   SwigDirector_ViewImpl *darg = 0;
64250
64251   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64252   arg2 = (Dali::Vector3 *)jarg2;
64253   if (!arg2) {
64254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64255     return ;
64256   }
64257   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64258   if (!darg) {
64259     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64260     return;
64261   }
64262   {
64263     try {
64264       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64265     } catch (std::out_of_range& e) {
64266       {
64267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64268       };
64269     } catch (std::exception& e) {
64270       {
64271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64272       };
64273     } catch (Dali::DaliException e) {
64274       {
64275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64276       };
64277     } catch (...) {
64278       {
64279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64280       };
64281     }
64282   }
64283
64284 }
64285
64286
64287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64288   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64289   Dali::Animation *arg2 = 0 ;
64290   Dali::Vector3 *arg3 = 0 ;
64291   SwigDirector_ViewImpl *darg = 0;
64292
64293   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64294   arg2 = (Dali::Animation *)jarg2;
64295   if (!arg2) {
64296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64297     return ;
64298   }
64299   arg3 = (Dali::Vector3 *)jarg3;
64300   if (!arg3) {
64301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64302     return ;
64303   }
64304   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64305   if (!darg) {
64306     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64307     return;
64308   }
64309   {
64310     try {
64311       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64312     } catch (std::out_of_range& e) {
64313       {
64314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64315       };
64316     } catch (std::exception& e) {
64317       {
64318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64319       };
64320     } catch (Dali::DaliException e) {
64321       {
64322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64323       };
64324     } catch (...) {
64325       {
64326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64327       };
64328     }
64329   }
64330
64331 }
64332
64333
64334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64335   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64336   Dali::Animation *arg2 = 0 ;
64337   Dali::Vector3 *arg3 = 0 ;
64338   SwigDirector_ViewImpl *darg = 0;
64339
64340   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64341   arg2 = (Dali::Animation *)jarg2;
64342   if (!arg2) {
64343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64344     return ;
64345   }
64346   arg3 = (Dali::Vector3 *)jarg3;
64347   if (!arg3) {
64348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64349     return ;
64350   }
64351   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64352   if (!darg) {
64353     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64354     return;
64355   }
64356   {
64357     try {
64358       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64359     } catch (std::out_of_range& e) {
64360       {
64361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64362       };
64363     } catch (std::exception& e) {
64364       {
64365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64366       };
64367     } catch (Dali::DaliException e) {
64368       {
64369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64370       };
64371     } catch (...) {
64372       {
64373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64374       };
64375     }
64376   }
64377
64378 }
64379
64380
64381 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64382   unsigned int jresult ;
64383   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64384   Dali::TouchEvent *arg2 = 0 ;
64385   SwigDirector_ViewImpl *darg = 0;
64386   bool result;
64387
64388   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64389   arg2 = (Dali::TouchEvent *)jarg2;
64390   if (!arg2) {
64391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64392     return 0;
64393   }
64394   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64395   if (!darg) {
64396     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64397     return 0;
64398   }
64399   {
64400     try {
64401       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64402     } catch (std::out_of_range& e) {
64403       {
64404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64405       };
64406     } catch (std::exception& e) {
64407       {
64408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64409       };
64410     } catch (Dali::DaliException e) {
64411       {
64412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64413       };
64414     } catch (...) {
64415       {
64416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64417       };
64418     }
64419   }
64420
64421   jresult = result;
64422   return jresult;
64423 }
64424
64425
64426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64427   unsigned int jresult ;
64428   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64429   Dali::TouchEvent *arg2 = 0 ;
64430   SwigDirector_ViewImpl *darg = 0;
64431   bool result;
64432
64433   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64434   arg2 = (Dali::TouchEvent *)jarg2;
64435   if (!arg2) {
64436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64437     return 0;
64438   }
64439   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64440   if (!darg) {
64441     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64442     return 0;
64443   }
64444   {
64445     try {
64446       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64447     } catch (std::out_of_range& e) {
64448       {
64449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64450       };
64451     } catch (std::exception& e) {
64452       {
64453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64454       };
64455     } catch (Dali::DaliException e) {
64456       {
64457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64458       };
64459     } catch (...) {
64460       {
64461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64462       };
64463     }
64464   }
64465
64466   jresult = result;
64467   return jresult;
64468 }
64469
64470
64471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64472   unsigned int jresult ;
64473   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64474   Dali::HoverEvent *arg2 = 0 ;
64475   SwigDirector_ViewImpl *darg = 0;
64476   bool result;
64477
64478   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64479   arg2 = (Dali::HoverEvent *)jarg2;
64480   if (!arg2) {
64481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64482     return 0;
64483   }
64484   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64485   if (!darg) {
64486     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64487     return 0;
64488   }
64489   {
64490     try {
64491       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64492     } catch (std::out_of_range& e) {
64493       {
64494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64495       };
64496     } catch (std::exception& e) {
64497       {
64498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64499       };
64500     } catch (Dali::DaliException e) {
64501       {
64502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64503       };
64504     } catch (...) {
64505       {
64506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64507       };
64508     }
64509   }
64510
64511   jresult = result;
64512   return jresult;
64513 }
64514
64515
64516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64517   unsigned int jresult ;
64518   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64519   Dali::HoverEvent *arg2 = 0 ;
64520   SwigDirector_ViewImpl *darg = 0;
64521   bool result;
64522
64523   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64524   arg2 = (Dali::HoverEvent *)jarg2;
64525   if (!arg2) {
64526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64527     return 0;
64528   }
64529   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64530   if (!darg) {
64531     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64532     return 0;
64533   }
64534   {
64535     try {
64536       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64537     } catch (std::out_of_range& e) {
64538       {
64539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64540       };
64541     } catch (std::exception& e) {
64542       {
64543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64544       };
64545     } catch (Dali::DaliException e) {
64546       {
64547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64548       };
64549     } catch (...) {
64550       {
64551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64552       };
64553     }
64554   }
64555
64556   jresult = result;
64557   return jresult;
64558 }
64559
64560
64561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64562   unsigned int jresult ;
64563   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64564   Dali::KeyEvent *arg2 = 0 ;
64565   SwigDirector_ViewImpl *darg = 0;
64566   bool result;
64567
64568   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64569   arg2 = (Dali::KeyEvent *)jarg2;
64570   if (!arg2) {
64571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64572     return 0;
64573   }
64574   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64575   if (!darg) {
64576     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64577     return 0;
64578   }
64579   {
64580     try {
64581       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64582     } catch (std::out_of_range& e) {
64583       {
64584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64585       };
64586     } catch (std::exception& e) {
64587       {
64588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64589       };
64590     } catch (Dali::DaliException e) {
64591       {
64592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64593       };
64594     } catch (...) {
64595       {
64596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64597       };
64598     }
64599   }
64600
64601   jresult = result;
64602   return jresult;
64603 }
64604
64605
64606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64607   unsigned int jresult ;
64608   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64609   Dali::KeyEvent *arg2 = 0 ;
64610   SwigDirector_ViewImpl *darg = 0;
64611   bool result;
64612
64613   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64614   arg2 = (Dali::KeyEvent *)jarg2;
64615   if (!arg2) {
64616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64617     return 0;
64618   }
64619   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64620   if (!darg) {
64621     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64622     return 0;
64623   }
64624   {
64625     try {
64626       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
64627     } catch (std::out_of_range& e) {
64628       {
64629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64630       };
64631     } catch (std::exception& e) {
64632       {
64633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64634       };
64635     } catch (Dali::DaliException e) {
64636       {
64637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64638       };
64639     } catch (...) {
64640       {
64641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64642       };
64643     }
64644   }
64645
64646   jresult = result;
64647   return jresult;
64648 }
64649
64650
64651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
64652   unsigned int jresult ;
64653   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64654   Dali::WheelEvent *arg2 = 0 ;
64655   SwigDirector_ViewImpl *darg = 0;
64656   bool result;
64657
64658   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64659   arg2 = (Dali::WheelEvent *)jarg2;
64660   if (!arg2) {
64661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64662     return 0;
64663   }
64664   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64665   if (!darg) {
64666     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64667     return 0;
64668   }
64669   {
64670     try {
64671       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
64672     } catch (std::out_of_range& e) {
64673       {
64674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64675       };
64676     } catch (std::exception& e) {
64677       {
64678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64679       };
64680     } catch (Dali::DaliException e) {
64681       {
64682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64683       };
64684     } catch (...) {
64685       {
64686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64687       };
64688     }
64689   }
64690
64691   jresult = result;
64692   return jresult;
64693 }
64694
64695
64696 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64697   unsigned int jresult ;
64698   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64699   Dali::WheelEvent *arg2 = 0 ;
64700   SwigDirector_ViewImpl *darg = 0;
64701   bool result;
64702
64703   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64704   arg2 = (Dali::WheelEvent *)jarg2;
64705   if (!arg2) {
64706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64707     return 0;
64708   }
64709   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64710   if (!darg) {
64711     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64712     return 0;
64713   }
64714   {
64715     try {
64716       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
64717     } catch (std::out_of_range& e) {
64718       {
64719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64720       };
64721     } catch (std::exception& e) {
64722       {
64723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64724       };
64725     } catch (Dali::DaliException e) {
64726       {
64727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64728       };
64729     } catch (...) {
64730       {
64731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64732       };
64733     }
64734   }
64735
64736   jresult = result;
64737   return jresult;
64738 }
64739
64740
64741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
64742   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64743   Dali::Vector2 *arg2 = 0 ;
64744   Dali::RelayoutContainer *arg3 = 0 ;
64745   SwigDirector_ViewImpl *darg = 0;
64746
64747   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64748   arg2 = (Dali::Vector2 *)jarg2;
64749   if (!arg2) {
64750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64751     return ;
64752   }
64753   arg3 = (Dali::RelayoutContainer *)jarg3;
64754   if (!arg3) {
64755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64756     return ;
64757   }
64758   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64759   if (!darg) {
64760     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64761     return;
64762   }
64763   {
64764     try {
64765       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
64766     } catch (std::out_of_range& e) {
64767       {
64768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64769       };
64770     } catch (std::exception& e) {
64771       {
64772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64773       };
64774     } catch (Dali::DaliException e) {
64775       {
64776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64777       };
64778     } catch (...) {
64779       {
64780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64781       };
64782     }
64783   }
64784
64785 }
64786
64787
64788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64789   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64790   Dali::Vector2 *arg2 = 0 ;
64791   Dali::RelayoutContainer *arg3 = 0 ;
64792   SwigDirector_ViewImpl *darg = 0;
64793
64794   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64795   arg2 = (Dali::Vector2 *)jarg2;
64796   if (!arg2) {
64797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64798     return ;
64799   }
64800   arg3 = (Dali::RelayoutContainer *)jarg3;
64801   if (!arg3) {
64802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64803     return ;
64804   }
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)->OnRelayoutSwigPublic((Dali::Vector2 const &)*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_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
64836   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64837   Dali::ResizePolicy::Type arg2 ;
64838   Dali::Dimension::Type arg3 ;
64839   SwigDirector_ViewImpl *darg = 0;
64840
64841   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64842   arg2 = (Dali::ResizePolicy::Type)jarg2;
64843   arg3 = (Dali::Dimension::Type)jarg3;
64844   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64845   if (!darg) {
64846     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64847     return;
64848   }
64849   {
64850     try {
64851       (darg)->OnSetResizePolicy(arg2,arg3);
64852     } catch (std::out_of_range& e) {
64853       {
64854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64855       };
64856     } catch (std::exception& e) {
64857       {
64858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64859       };
64860     } catch (Dali::DaliException e) {
64861       {
64862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64863       };
64864     } catch (...) {
64865       {
64866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64867       };
64868     }
64869   }
64870
64871 }
64872
64873
64874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
64875   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64876   Dali::ResizePolicy::Type arg2 ;
64877   Dali::Dimension::Type arg3 ;
64878   SwigDirector_ViewImpl *darg = 0;
64879
64880   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64881   arg2 = (Dali::ResizePolicy::Type)jarg2;
64882   arg3 = (Dali::Dimension::Type)jarg3;
64883   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64884   if (!darg) {
64885     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64886     return;
64887   }
64888   {
64889     try {
64890       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
64891     } catch (std::out_of_range& e) {
64892       {
64893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64894       };
64895     } catch (std::exception& e) {
64896       {
64897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64898       };
64899     } catch (Dali::DaliException e) {
64900       {
64901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64902       };
64903     } catch (...) {
64904       {
64905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64906       };
64907     }
64908   }
64909
64910 }
64911
64912
64913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
64914   void * jresult ;
64915   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64916   SwigDirector_ViewImpl *darg = 0;
64917   Dali::Vector3 result;
64918
64919   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64920   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64921   if (!darg) {
64922     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64923     return 0;
64924   }
64925   {
64926     try {
64927       result = (darg)->GetNaturalSize();
64928     } catch (std::out_of_range& e) {
64929       {
64930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64931       };
64932     } catch (std::exception& e) {
64933       {
64934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64935       };
64936     } catch (Dali::DaliException e) {
64937       {
64938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64939       };
64940     } catch (...) {
64941       {
64942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64943       };
64944     }
64945   }
64946
64947   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64948   return jresult;
64949 }
64950
64951
64952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
64953   void * jresult ;
64954   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64955   SwigDirector_ViewImpl *darg = 0;
64956   Dali::Vector3 result;
64957
64958   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64959   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64960   if (!darg) {
64961     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64962     return 0;
64963   }
64964   {
64965     try {
64966       result = (darg)->GetNaturalSizeSwigPublic();
64967     } catch (std::out_of_range& e) {
64968       {
64969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64970       };
64971     } catch (std::exception& e) {
64972       {
64973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64974       };
64975     } catch (Dali::DaliException e) {
64976       {
64977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64978       };
64979     } catch (...) {
64980       {
64981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64982       };
64983     }
64984   }
64985
64986   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64987   return jresult;
64988 }
64989
64990
64991 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
64992   float jresult ;
64993   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64994   Dali::Actor *arg2 = 0 ;
64995   Dali::Dimension::Type arg3 ;
64996   SwigDirector_ViewImpl *darg = 0;
64997   float result;
64998
64999   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65000   arg2 = (Dali::Actor *)jarg2;
65001   if (!arg2) {
65002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65003     return 0;
65004   }
65005   arg3 = (Dali::Dimension::Type)jarg3;
65006   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65007   if (!darg) {
65008     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65009     return 0;
65010   }
65011   {
65012     try {
65013       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65014     } catch (std::out_of_range& e) {
65015       {
65016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65017       };
65018     } catch (std::exception& e) {
65019       {
65020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65021       };
65022     } catch (Dali::DaliException e) {
65023       {
65024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65025       };
65026     } catch (...) {
65027       {
65028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65029       };
65030     }
65031   }
65032
65033   jresult = result;
65034   return jresult;
65035 }
65036
65037
65038 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65039   float jresult ;
65040   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65041   Dali::Actor *arg2 = 0 ;
65042   Dali::Dimension::Type arg3 ;
65043   SwigDirector_ViewImpl *darg = 0;
65044   float result;
65045
65046   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65047   arg2 = (Dali::Actor *)jarg2;
65048   if (!arg2) {
65049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65050     return 0;
65051   }
65052   arg3 = (Dali::Dimension::Type)jarg3;
65053   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65054   if (!darg) {
65055     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65056     return 0;
65057   }
65058   {
65059     try {
65060       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65061     } catch (std::out_of_range& e) {
65062       {
65063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65064       };
65065     } catch (std::exception& e) {
65066       {
65067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65068       };
65069     } catch (Dali::DaliException e) {
65070       {
65071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65072       };
65073     } catch (...) {
65074       {
65075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65076       };
65077     }
65078   }
65079
65080   jresult = result;
65081   return jresult;
65082 }
65083
65084
65085 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65086   float jresult ;
65087   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65088   float arg2 ;
65089   SwigDirector_ViewImpl *darg = 0;
65090   float result;
65091
65092   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65093   arg2 = (float)jarg2;
65094   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65095   if (!darg) {
65096     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65097     return 0;
65098   }
65099   {
65100     try {
65101       result = (float)(darg)->GetHeightForWidth(arg2);
65102     } catch (std::out_of_range& e) {
65103       {
65104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65105       };
65106     } catch (std::exception& e) {
65107       {
65108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65109       };
65110     } catch (Dali::DaliException e) {
65111       {
65112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65113       };
65114     } catch (...) {
65115       {
65116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65117       };
65118     }
65119   }
65120
65121   jresult = result;
65122   return jresult;
65123 }
65124
65125
65126 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65127   float jresult ;
65128   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65129   float arg2 ;
65130   SwigDirector_ViewImpl *darg = 0;
65131   float result;
65132
65133   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65134   arg2 = (float)jarg2;
65135   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65136   if (!darg) {
65137     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65138     return 0;
65139   }
65140   {
65141     try {
65142       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65143     } catch (std::out_of_range& e) {
65144       {
65145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65146       };
65147     } catch (std::exception& e) {
65148       {
65149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65150       };
65151     } catch (Dali::DaliException e) {
65152       {
65153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65154       };
65155     } catch (...) {
65156       {
65157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65158       };
65159     }
65160   }
65161
65162   jresult = result;
65163   return jresult;
65164 }
65165
65166
65167 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65168   float jresult ;
65169   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65170   float arg2 ;
65171   SwigDirector_ViewImpl *darg = 0;
65172   float result;
65173
65174   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65175   arg2 = (float)jarg2;
65176   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65177   if (!darg) {
65178     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65179     return 0;
65180   }
65181   {
65182     try {
65183       result = (float)(darg)->GetWidthForHeight(arg2);
65184     } catch (std::out_of_range& e) {
65185       {
65186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65187       };
65188     } catch (std::exception& e) {
65189       {
65190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65191       };
65192     } catch (Dali::DaliException e) {
65193       {
65194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65195       };
65196     } catch (...) {
65197       {
65198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65199       };
65200     }
65201   }
65202
65203   jresult = result;
65204   return jresult;
65205 }
65206
65207
65208 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65209   float jresult ;
65210   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65211   float arg2 ;
65212   SwigDirector_ViewImpl *darg = 0;
65213   float result;
65214
65215   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65216   arg2 = (float)jarg2;
65217   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65218   if (!darg) {
65219     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65220     return 0;
65221   }
65222   {
65223     try {
65224       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65225     } catch (std::out_of_range& e) {
65226       {
65227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65228       };
65229     } catch (std::exception& e) {
65230       {
65231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65232       };
65233     } catch (Dali::DaliException e) {
65234       {
65235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65236       };
65237     } catch (...) {
65238       {
65239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65240       };
65241     }
65242   }
65243
65244   jresult = result;
65245   return jresult;
65246 }
65247
65248
65249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65250   unsigned int jresult ;
65251   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65252   Dali::Dimension::Type arg2 ;
65253   SwigDirector_ViewImpl *darg = 0;
65254   bool result;
65255
65256   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65257   arg2 = (Dali::Dimension::Type)jarg2;
65258   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65259   if (!darg) {
65260     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65261     return 0;
65262   }
65263   {
65264     try {
65265       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65266     } catch (std::out_of_range& e) {
65267       {
65268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65269       };
65270     } catch (std::exception& e) {
65271       {
65272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65273       };
65274     } catch (Dali::DaliException e) {
65275       {
65276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65277       };
65278     } catch (...) {
65279       {
65280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65281       };
65282     }
65283   }
65284
65285   jresult = result;
65286   return jresult;
65287 }
65288
65289
65290 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65291   unsigned int jresult ;
65292   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65293   Dali::Dimension::Type arg2 ;
65294   SwigDirector_ViewImpl *darg = 0;
65295   bool result;
65296
65297   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65298   arg2 = (Dali::Dimension::Type)jarg2;
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(arg2);
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 unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65332   unsigned int jresult ;
65333   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65334   SwigDirector_ViewImpl *darg = 0;
65335   bool result;
65336
65337   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
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 0;
65342   }
65343   {
65344     try {
65345       result = (bool)(darg)->RelayoutDependentOnChildren();
65346     } catch (std::out_of_range& e) {
65347       {
65348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65349       };
65350     } catch (std::exception& e) {
65351       {
65352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65353       };
65354     } catch (Dali::DaliException e) {
65355       {
65356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65357       };
65358     } catch (...) {
65359       {
65360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65361       };
65362     }
65363   }
65364
65365   jresult = result;
65366   return jresult;
65367 }
65368
65369
65370 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65371   unsigned int jresult ;
65372   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65373   SwigDirector_ViewImpl *darg = 0;
65374   bool result;
65375
65376   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65377   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65378   if (!darg) {
65379     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65380     return 0;
65381   }
65382   {
65383     try {
65384       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65385     } catch (std::out_of_range& e) {
65386       {
65387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65388       };
65389     } catch (std::exception& e) {
65390       {
65391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65392       };
65393     } catch (Dali::DaliException e) {
65394       {
65395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65396       };
65397     } catch (...) {
65398       {
65399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65400       };
65401     }
65402   }
65403
65404   jresult = result;
65405   return jresult;
65406 }
65407
65408
65409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65410   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65411   Dali::Dimension::Type arg2 ;
65412   SwigDirector_ViewImpl *darg = 0;
65413
65414   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65415   arg2 = (Dali::Dimension::Type)jarg2;
65416   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65417   if (!darg) {
65418     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65419     return;
65420   }
65421   {
65422     try {
65423       (darg)->OnCalculateRelayoutSize(arg2);
65424     } catch (std::out_of_range& e) {
65425       {
65426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65427       };
65428     } catch (std::exception& e) {
65429       {
65430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65431       };
65432     } catch (Dali::DaliException e) {
65433       {
65434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65435       };
65436     } catch (...) {
65437       {
65438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65439       };
65440     }
65441   }
65442
65443 }
65444
65445
65446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65447   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65448   Dali::Dimension::Type arg2 ;
65449   SwigDirector_ViewImpl *darg = 0;
65450
65451   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65452   arg2 = (Dali::Dimension::Type)jarg2;
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)->OnCalculateRelayoutSizeSwigPublic(arg2);
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_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65484   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65485   float arg2 ;
65486   Dali::Dimension::Type arg3 ;
65487   SwigDirector_ViewImpl *darg = 0;
65488
65489   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65490   arg2 = (float)jarg2;
65491   arg3 = (Dali::Dimension::Type)jarg3;
65492   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65493   if (!darg) {
65494     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65495     return;
65496   }
65497   {
65498     try {
65499       (darg)->OnLayoutNegotiated(arg2,arg3);
65500     } catch (std::out_of_range& e) {
65501       {
65502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65503       };
65504     } catch (std::exception& e) {
65505       {
65506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65507       };
65508     } catch (Dali::DaliException e) {
65509       {
65510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65511       };
65512     } catch (...) {
65513       {
65514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65515       };
65516     }
65517   }
65518
65519 }
65520
65521
65522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65523   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65524   float arg2 ;
65525   Dali::Dimension::Type arg3 ;
65526   SwigDirector_ViewImpl *darg = 0;
65527
65528   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65529   arg2 = (float)jarg2;
65530   arg3 = (Dali::Dimension::Type)jarg3;
65531   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65532   if (!darg) {
65533     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65534     return;
65535   }
65536   {
65537     try {
65538       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65539     } catch (std::out_of_range& e) {
65540       {
65541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65542       };
65543     } catch (std::exception& e) {
65544       {
65545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65546       };
65547     } catch (Dali::DaliException e) {
65548       {
65549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65550       };
65551     } catch (...) {
65552       {
65553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65554       };
65555     }
65556   }
65557
65558 }
65559
65560
65561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65562   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65563
65564   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65565   {
65566     try {
65567       (arg1)->OnInitialize();
65568     } catch (std::out_of_range& e) {
65569       {
65570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65571       };
65572     } catch (std::exception& e) {
65573       {
65574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65575       };
65576     } catch (Dali::DaliException e) {
65577       {
65578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65579       };
65580     } catch (...) {
65581       {
65582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65583       };
65584     }
65585   }
65586
65587 }
65588
65589
65590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65591   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65592
65593   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65594   {
65595     try {
65596       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65597     } catch (std::out_of_range& e) {
65598       {
65599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65600       };
65601     } catch (std::exception& e) {
65602       {
65603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65604       };
65605     } catch (Dali::DaliException e) {
65606       {
65607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65608       };
65609     } catch (...) {
65610       {
65611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65612       };
65613     }
65614   }
65615
65616 }
65617
65618
65619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
65620   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65621   Dali::Actor *arg2 = 0 ;
65622
65623   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65624   arg2 = (Dali::Actor *)jarg2;
65625   if (!arg2) {
65626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65627     return ;
65628   }
65629   {
65630     try {
65631       (arg1)->OnControlChildAdd(*arg2);
65632     } catch (std::out_of_range& e) {
65633       {
65634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65635       };
65636     } catch (std::exception& e) {
65637       {
65638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65639       };
65640     } catch (Dali::DaliException e) {
65641       {
65642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65643       };
65644     } catch (...) {
65645       {
65646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65647       };
65648     }
65649   }
65650
65651 }
65652
65653
65654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65655   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65656   Dali::Actor *arg2 = 0 ;
65657
65658   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65659   arg2 = (Dali::Actor *)jarg2;
65660   if (!arg2) {
65661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65662     return ;
65663   }
65664   {
65665     try {
65666       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
65667     } catch (std::out_of_range& e) {
65668       {
65669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65670       };
65671     } catch (std::exception& e) {
65672       {
65673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65674       };
65675     } catch (Dali::DaliException e) {
65676       {
65677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65678       };
65679     } catch (...) {
65680       {
65681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65682       };
65683     }
65684   }
65685
65686 }
65687
65688
65689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
65690   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65691   Dali::Actor *arg2 = 0 ;
65692
65693   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65694   arg2 = (Dali::Actor *)jarg2;
65695   if (!arg2) {
65696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65697     return ;
65698   }
65699   {
65700     try {
65701       (arg1)->OnControlChildRemove(*arg2);
65702     } catch (std::out_of_range& e) {
65703       {
65704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65705       };
65706     } catch (std::exception& e) {
65707       {
65708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65709       };
65710     } catch (Dali::DaliException e) {
65711       {
65712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65713       };
65714     } catch (...) {
65715       {
65716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65717       };
65718     }
65719   }
65720
65721 }
65722
65723
65724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65725   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65726   Dali::Actor *arg2 = 0 ;
65727
65728   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65729   arg2 = (Dali::Actor *)jarg2;
65730   if (!arg2) {
65731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65732     return ;
65733   }
65734   {
65735     try {
65736       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
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 void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
65760   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65761   Dali::Toolkit::StyleManager arg2 ;
65762   Dali::StyleChange::Type arg3 ;
65763   Dali::Toolkit::StyleManager *argp2 ;
65764
65765   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65766   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65767   if (!argp2) {
65768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65769     return ;
65770   }
65771   arg2 = *argp2;
65772   arg3 = (Dali::StyleChange::Type)jarg3;
65773   {
65774     try {
65775       (arg1)->OnStyleChange(arg2,arg3);
65776     } catch (std::out_of_range& e) {
65777       {
65778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65779       };
65780     } catch (std::exception& e) {
65781       {
65782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65783       };
65784     } catch (Dali::DaliException e) {
65785       {
65786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65787       };
65788     } catch (...) {
65789       {
65790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65791       };
65792     }
65793   }
65794
65795 }
65796
65797
65798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65799   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65800   Dali::Toolkit::StyleManager arg2 ;
65801   Dali::StyleChange::Type arg3 ;
65802   Dali::Toolkit::StyleManager *argp2 ;
65803
65804   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65805   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65806   if (!argp2) {
65807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65808     return ;
65809   }
65810   arg2 = *argp2;
65811   arg3 = (Dali::StyleChange::Type)jarg3;
65812   {
65813     try {
65814       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
65815     } catch (std::out_of_range& e) {
65816       {
65817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65818       };
65819     } catch (std::exception& e) {
65820       {
65821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65822       };
65823     } catch (Dali::DaliException e) {
65824       {
65825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65826       };
65827     } catch (...) {
65828       {
65829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65830       };
65831     }
65832   }
65833
65834 }
65835
65836
65837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
65838   unsigned int jresult ;
65839   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65840   bool result;
65841
65842   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65843   {
65844     try {
65845       result = (bool)(arg1)->OnAccessibilityActivated();
65846     } catch (std::out_of_range& e) {
65847       {
65848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65849       };
65850     } catch (std::exception& e) {
65851       {
65852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65853       };
65854     } catch (Dali::DaliException e) {
65855       {
65856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65857       };
65858     } catch (...) {
65859       {
65860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65861       };
65862     }
65863   }
65864
65865   jresult = result;
65866   return jresult;
65867 }
65868
65869
65870 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
65871   unsigned int jresult ;
65872   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65873   bool result;
65874
65875   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65876   {
65877     try {
65878       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
65879     } catch (std::out_of_range& e) {
65880       {
65881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65882       };
65883     } catch (std::exception& e) {
65884       {
65885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65886       };
65887     } catch (Dali::DaliException e) {
65888       {
65889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65890       };
65891     } catch (...) {
65892       {
65893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65894       };
65895     }
65896   }
65897
65898   jresult = result;
65899   return jresult;
65900 }
65901
65902
65903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
65904   unsigned int jresult ;
65905   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65906   Dali::PanGesture arg2 ;
65907   Dali::PanGesture *argp2 ;
65908   bool result;
65909
65910   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65911   argp2 = (Dali::PanGesture *)jarg2;
65912   if (!argp2) {
65913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65914     return 0;
65915   }
65916   arg2 = *argp2;
65917   {
65918     try {
65919       result = (bool)(arg1)->OnAccessibilityPan(arg2);
65920     } catch (std::out_of_range& e) {
65921       {
65922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65923       };
65924     } catch (std::exception& e) {
65925       {
65926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65927       };
65928     } catch (Dali::DaliException e) {
65929       {
65930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65931       };
65932     } catch (...) {
65933       {
65934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65935       };
65936     }
65937   }
65938
65939   jresult = result;
65940   return jresult;
65941 }
65942
65943
65944 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65945   unsigned int jresult ;
65946   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65947   Dali::PanGesture arg2 ;
65948   Dali::PanGesture *argp2 ;
65949   bool result;
65950
65951   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65952   argp2 = (Dali::PanGesture *)jarg2;
65953   if (!argp2) {
65954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65955     return 0;
65956   }
65957   arg2 = *argp2;
65958   {
65959     try {
65960       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(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_OnAccessibilityTouch(void * jarg1, void * jarg2) {
65986   unsigned int jresult ;
65987   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65988   Dali::TouchEvent *arg2 = 0 ;
65989   bool result;
65990
65991   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65992   arg2 = (Dali::TouchEvent *)jarg2;
65993   if (!arg2) {
65994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65995     return 0;
65996   }
65997   {
65998     try {
65999       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66000     } catch (std::out_of_range& e) {
66001       {
66002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66003       };
66004     } catch (std::exception& e) {
66005       {
66006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66007       };
66008     } catch (Dali::DaliException e) {
66009       {
66010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66011       };
66012     } catch (...) {
66013       {
66014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66015       };
66016     }
66017   }
66018
66019   jresult = result;
66020   return jresult;
66021 }
66022
66023
66024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66025   unsigned int jresult ;
66026   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66027   Dali::TouchEvent *arg2 = 0 ;
66028   bool result;
66029
66030   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66031   arg2 = (Dali::TouchEvent *)jarg2;
66032   if (!arg2) {
66033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66034     return 0;
66035   }
66036   {
66037     try {
66038       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66039     } catch (std::out_of_range& e) {
66040       {
66041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66042       };
66043     } catch (std::exception& e) {
66044       {
66045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66046       };
66047     } catch (Dali::DaliException e) {
66048       {
66049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66050       };
66051     } catch (...) {
66052       {
66053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66054       };
66055     }
66056   }
66057
66058   jresult = result;
66059   return jresult;
66060 }
66061
66062
66063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66064   unsigned int jresult ;
66065   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66066   bool arg2 ;
66067   bool result;
66068
66069   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66070   arg2 = jarg2 ? true : false;
66071   {
66072     try {
66073       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66074     } catch (std::out_of_range& e) {
66075       {
66076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66077       };
66078     } catch (std::exception& e) {
66079       {
66080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66081       };
66082     } catch (Dali::DaliException e) {
66083       {
66084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66085       };
66086     } catch (...) {
66087       {
66088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66089       };
66090     }
66091   }
66092
66093   jresult = result;
66094   return jresult;
66095 }
66096
66097
66098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66099   unsigned int jresult ;
66100   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66101   bool arg2 ;
66102   bool result;
66103
66104   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66105   arg2 = jarg2 ? true : false;
66106   {
66107     try {
66108       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66109     } catch (std::out_of_range& e) {
66110       {
66111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66112       };
66113     } catch (std::exception& e) {
66114       {
66115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66116       };
66117     } catch (Dali::DaliException e) {
66118       {
66119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66120       };
66121     } catch (...) {
66122       {
66123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66124       };
66125     }
66126   }
66127
66128   jresult = result;
66129   return jresult;
66130 }
66131
66132
66133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66134   unsigned int jresult ;
66135   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66136   bool result;
66137
66138   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66139   {
66140     try {
66141       result = (bool)(arg1)->OnAccessibilityZoom();
66142     } catch (std::out_of_range& e) {
66143       {
66144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66145       };
66146     } catch (std::exception& e) {
66147       {
66148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66149       };
66150     } catch (Dali::DaliException e) {
66151       {
66152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66153       };
66154     } catch (...) {
66155       {
66156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66157       };
66158     }
66159   }
66160
66161   jresult = result;
66162   return jresult;
66163 }
66164
66165
66166 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66167   unsigned int jresult ;
66168   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66169   bool result;
66170
66171   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66172   {
66173     try {
66174       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66175     } catch (std::out_of_range& e) {
66176       {
66177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66178       };
66179     } catch (std::exception& e) {
66180       {
66181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66182       };
66183     } catch (Dali::DaliException e) {
66184       {
66185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66186       };
66187     } catch (...) {
66188       {
66189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66190       };
66191     }
66192   }
66193
66194   jresult = result;
66195   return jresult;
66196 }
66197
66198
66199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66200   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66201
66202   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66203   {
66204     try {
66205       (arg1)->OnKeyInputFocusGained();
66206     } catch (std::out_of_range& e) {
66207       {
66208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66209       };
66210     } catch (std::exception& e) {
66211       {
66212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66213       };
66214     } catch (Dali::DaliException e) {
66215       {
66216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66217       };
66218     } catch (...) {
66219       {
66220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66221       };
66222     }
66223   }
66224
66225 }
66226
66227
66228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66229   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66230
66231   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66232   {
66233     try {
66234       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66235     } catch (std::out_of_range& e) {
66236       {
66237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66238       };
66239     } catch (std::exception& e) {
66240       {
66241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66242       };
66243     } catch (Dali::DaliException e) {
66244       {
66245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66246       };
66247     } catch (...) {
66248       {
66249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66250       };
66251     }
66252   }
66253
66254 }
66255
66256
66257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66258   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66259
66260   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66261   {
66262     try {
66263       (arg1)->OnKeyInputFocusLost();
66264     } catch (std::out_of_range& e) {
66265       {
66266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66267       };
66268     } catch (std::exception& e) {
66269       {
66270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66271       };
66272     } catch (Dali::DaliException e) {
66273       {
66274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66275       };
66276     } catch (...) {
66277       {
66278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66279       };
66280     }
66281   }
66282
66283 }
66284
66285
66286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66287   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66288
66289   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66290   {
66291     try {
66292       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66293     } catch (std::out_of_range& e) {
66294       {
66295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66296       };
66297     } catch (std::exception& e) {
66298       {
66299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66300       };
66301     } catch (Dali::DaliException e) {
66302       {
66303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66304       };
66305     } catch (...) {
66306       {
66307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66308       };
66309     }
66310   }
66311
66312 }
66313
66314
66315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66316   void * jresult ;
66317   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66318   Dali::Actor arg2 ;
66319   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66320   bool arg4 ;
66321   Dali::Actor *argp2 ;
66322   Dali::Actor result;
66323
66324   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66325   argp2 = (Dali::Actor *)jarg2;
66326   if (!argp2) {
66327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66328     return 0;
66329   }
66330   arg2 = *argp2;
66331   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66332   arg4 = jarg4 ? true : false;
66333   {
66334     try {
66335       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66336     } catch (std::out_of_range& e) {
66337       {
66338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66339       };
66340     } catch (std::exception& e) {
66341       {
66342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66343       };
66344     } catch (Dali::DaliException e) {
66345       {
66346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66347       };
66348     } catch (...) {
66349       {
66350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66351       };
66352     }
66353   }
66354
66355   jresult = new Dali::Actor((const Dali::Actor &)result);
66356   return jresult;
66357 }
66358
66359
66360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66361   void * jresult ;
66362   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66363   Dali::Actor arg2 ;
66364   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66365   bool arg4 ;
66366   Dali::Actor *argp2 ;
66367   Dali::Actor result;
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 0;
66374   }
66375   arg2 = *argp2;
66376   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66377   arg4 = jarg4 ? true : false;
66378   {
66379     try {
66380       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66381     } catch (std::out_of_range& e) {
66382       {
66383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66384       };
66385     } catch (std::exception& e) {
66386       {
66387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66388       };
66389     } catch (Dali::DaliException e) {
66390       {
66391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66392       };
66393     } catch (...) {
66394       {
66395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66396       };
66397     }
66398   }
66399
66400   jresult = new Dali::Actor((const Dali::Actor &)result);
66401   return jresult;
66402 }
66403
66404
66405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66406   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66407   Dali::Actor arg2 ;
66408   Dali::Actor *argp2 ;
66409
66410   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66411   argp2 = (Dali::Actor *)jarg2;
66412   if (!argp2) {
66413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66414     return ;
66415   }
66416   arg2 = *argp2;
66417   {
66418     try {
66419       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66420     } catch (std::out_of_range& e) {
66421       {
66422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66423       };
66424     } catch (std::exception& e) {
66425       {
66426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66427       };
66428     } catch (Dali::DaliException e) {
66429       {
66430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66431       };
66432     } catch (...) {
66433       {
66434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66435       };
66436     }
66437   }
66438
66439 }
66440
66441
66442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66443   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66444   Dali::Actor arg2 ;
66445   Dali::Actor *argp2 ;
66446
66447   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66448   argp2 = (Dali::Actor *)jarg2;
66449   if (!argp2) {
66450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66451     return ;
66452   }
66453   arg2 = *argp2;
66454   {
66455     try {
66456       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66457     } catch (std::out_of_range& e) {
66458       {
66459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66460       };
66461     } catch (std::exception& e) {
66462       {
66463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66464       };
66465     } catch (Dali::DaliException e) {
66466       {
66467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66468       };
66469     } catch (...) {
66470       {
66471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66472       };
66473     }
66474   }
66475
66476 }
66477
66478
66479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66480   unsigned int jresult ;
66481   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66482   bool result;
66483
66484   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66485   {
66486     try {
66487       result = (bool)(arg1)->OnKeyboardEnter();
66488     } catch (std::out_of_range& e) {
66489       {
66490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66491       };
66492     } catch (std::exception& e) {
66493       {
66494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66495       };
66496     } catch (Dali::DaliException e) {
66497       {
66498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66499       };
66500     } catch (...) {
66501       {
66502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66503       };
66504     }
66505   }
66506
66507   jresult = result;
66508   return jresult;
66509 }
66510
66511
66512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66513   unsigned int jresult ;
66514   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66515   bool result;
66516
66517   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66518   {
66519     try {
66520       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66521     } catch (std::out_of_range& e) {
66522       {
66523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66524       };
66525     } catch (std::exception& e) {
66526       {
66527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66528       };
66529     } catch (Dali::DaliException e) {
66530       {
66531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66532       };
66533     } catch (...) {
66534       {
66535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66536       };
66537     }
66538   }
66539
66540   jresult = result;
66541   return jresult;
66542 }
66543
66544
66545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66546   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66547   Dali::PinchGesture *arg2 = 0 ;
66548
66549   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66550   arg2 = (Dali::PinchGesture *)jarg2;
66551   if (!arg2) {
66552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66553     return ;
66554   }
66555   {
66556     try {
66557       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66558     } catch (std::out_of_range& e) {
66559       {
66560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66561       };
66562     } catch (std::exception& e) {
66563       {
66564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66565       };
66566     } catch (Dali::DaliException e) {
66567       {
66568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66569       };
66570     } catch (...) {
66571       {
66572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66573       };
66574     }
66575   }
66576
66577 }
66578
66579
66580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66581   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66582   Dali::PinchGesture *arg2 = 0 ;
66583
66584   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66585   arg2 = (Dali::PinchGesture *)jarg2;
66586   if (!arg2) {
66587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66588     return ;
66589   }
66590   {
66591     try {
66592       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66593     } catch (std::out_of_range& e) {
66594       {
66595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66596       };
66597     } catch (std::exception& e) {
66598       {
66599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66600       };
66601     } catch (Dali::DaliException e) {
66602       {
66603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66604       };
66605     } catch (...) {
66606       {
66607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66608       };
66609     }
66610   }
66611
66612 }
66613
66614
66615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
66616   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66617   Dali::PanGesture *arg2 = 0 ;
66618
66619   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66620   arg2 = (Dali::PanGesture *)jarg2;
66621   if (!arg2) {
66622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66623     return ;
66624   }
66625   {
66626     try {
66627       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
66628     } catch (std::out_of_range& e) {
66629       {
66630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66631       };
66632     } catch (std::exception& e) {
66633       {
66634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66635       };
66636     } catch (Dali::DaliException e) {
66637       {
66638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66639       };
66640     } catch (...) {
66641       {
66642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66643       };
66644     }
66645   }
66646
66647 }
66648
66649
66650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66651   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66652   Dali::PanGesture *arg2 = 0 ;
66653
66654   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66655   arg2 = (Dali::PanGesture *)jarg2;
66656   if (!arg2) {
66657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66658     return ;
66659   }
66660   {
66661     try {
66662       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
66663     } catch (std::out_of_range& e) {
66664       {
66665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66666       };
66667     } catch (std::exception& e) {
66668       {
66669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66670       };
66671     } catch (Dali::DaliException e) {
66672       {
66673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66674       };
66675     } catch (...) {
66676       {
66677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66678       };
66679     }
66680   }
66681
66682 }
66683
66684
66685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
66686   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66687   Dali::TapGesture *arg2 = 0 ;
66688
66689   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66690   arg2 = (Dali::TapGesture *)jarg2;
66691   if (!arg2) {
66692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66693     return ;
66694   }
66695   {
66696     try {
66697       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
66698     } catch (std::out_of_range& e) {
66699       {
66700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66701       };
66702     } catch (std::exception& e) {
66703       {
66704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66705       };
66706     } catch (Dali::DaliException e) {
66707       {
66708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66709       };
66710     } catch (...) {
66711       {
66712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66713       };
66714     }
66715   }
66716
66717 }
66718
66719
66720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66721   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66722   Dali::TapGesture *arg2 = 0 ;
66723
66724   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66725   arg2 = (Dali::TapGesture *)jarg2;
66726   if (!arg2) {
66727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66728     return ;
66729   }
66730   {
66731     try {
66732       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
66733     } catch (std::out_of_range& e) {
66734       {
66735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66736       };
66737     } catch (std::exception& e) {
66738       {
66739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66740       };
66741     } catch (Dali::DaliException e) {
66742       {
66743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66744       };
66745     } catch (...) {
66746       {
66747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66748       };
66749     }
66750   }
66751
66752 }
66753
66754
66755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
66756   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66757   Dali::LongPressGesture *arg2 = 0 ;
66758
66759   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66760   arg2 = (Dali::LongPressGesture *)jarg2;
66761   if (!arg2) {
66762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66763     return ;
66764   }
66765   {
66766     try {
66767       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
66768     } catch (std::out_of_range& e) {
66769       {
66770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66771       };
66772     } catch (std::exception& e) {
66773       {
66774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66775       };
66776     } catch (Dali::DaliException e) {
66777       {
66778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66779       };
66780     } catch (...) {
66781       {
66782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66783       };
66784     }
66785   }
66786
66787 }
66788
66789
66790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66791   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66792   Dali::LongPressGesture *arg2 = 0 ;
66793
66794   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66795   arg2 = (Dali::LongPressGesture *)jarg2;
66796   if (!arg2) {
66797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66798     return ;
66799   }
66800   {
66801     try {
66802       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
66803     } catch (std::out_of_range& e) {
66804       {
66805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66806       };
66807     } catch (std::exception& e) {
66808       {
66809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66810       };
66811     } catch (Dali::DaliException e) {
66812       {
66813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66814       };
66815     } catch (...) {
66816       {
66817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66818       };
66819     }
66820   }
66821
66822 }
66823
66824
66825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
66826   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66827   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66828   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66829
66830   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66831   arg2 = (Dali::SlotObserver *)jarg2;
66832   arg3 = (Dali::CallbackBase *)jarg3;
66833   {
66834     try {
66835       (arg1)->SignalConnected(arg2,arg3);
66836     } catch (std::out_of_range& e) {
66837       {
66838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66839       };
66840     } catch (std::exception& e) {
66841       {
66842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66843       };
66844     } catch (Dali::DaliException e) {
66845       {
66846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66847       };
66848     } catch (...) {
66849       {
66850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66851       };
66852     }
66853   }
66854
66855 }
66856
66857
66858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66859   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66860   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66861   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66862
66863   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66864   arg2 = (Dali::SlotObserver *)jarg2;
66865   arg3 = (Dali::CallbackBase *)jarg3;
66866   {
66867     try {
66868       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
66869     } catch (std::out_of_range& e) {
66870       {
66871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66872       };
66873     } catch (std::exception& e) {
66874       {
66875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66876       };
66877     } catch (Dali::DaliException e) {
66878       {
66879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66880       };
66881     } catch (...) {
66882       {
66883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66884       };
66885     }
66886   }
66887
66888 }
66889
66890
66891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
66892   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66893   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66894   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66895
66896   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66897   arg2 = (Dali::SlotObserver *)jarg2;
66898   arg3 = (Dali::CallbackBase *)jarg3;
66899   {
66900     try {
66901       (arg1)->SignalDisconnected(arg2,arg3);
66902     } catch (std::out_of_range& e) {
66903       {
66904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66905       };
66906     } catch (std::exception& e) {
66907       {
66908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66909       };
66910     } catch (Dali::DaliException e) {
66911       {
66912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66913       };
66914     } catch (...) {
66915       {
66916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66917       };
66918     }
66919   }
66920
66921 }
66922
66923
66924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66925   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66926   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66927   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66928
66929   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66930   arg2 = (Dali::SlotObserver *)jarg2;
66931   arg3 = (Dali::CallbackBase *)jarg3;
66932   {
66933     try {
66934       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
66935     } catch (std::out_of_range& e) {
66936       {
66937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66938       };
66939     } catch (std::exception& e) {
66940       {
66941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66942       };
66943     } catch (Dali::DaliException e) {
66944       {
66945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66946       };
66947     } catch (...) {
66948       {
66949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66950       };
66951     }
66952   }
66953
66954 }
66955
66956
66957 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) {
66958   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
66959   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
66960   if (director) {
66961     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);
66962   }
66963 }
66964
66965
66966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
66967   void * jresult ;
66968   Dali::Toolkit::Control *arg1 = 0 ;
66969   Dali::Toolkit::Internal::Control *result = 0 ;
66970
66971   arg1 = (Dali::Toolkit::Control *)jarg1;
66972   if (!arg1) {
66973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
66974     return 0;
66975   }
66976   {
66977     try {
66978       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
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 int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
67004   int jresult ;
67005   int result;
67006
67007   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
67008   jresult = (int)result;
67009   return jresult;
67010 }
67011
67012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67013   int jresult ;
67014   int result;
67015
67016   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67017   jresult = (int)result;
67018   return jresult;
67019 }
67020
67021
67022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67023   int jresult ;
67024   int result;
67025
67026   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67027   jresult = (int)result;
67028   return jresult;
67029 }
67030
67031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67032   int jresult ;
67033   int result;
67034
67035   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67036   jresult = (int)result;
67037   return jresult;
67038 }
67039
67040
67041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67042   int jresult ;
67043   int result;
67044
67045   result = (int)Dali::Toolkit::Control::Property::PADDING;
67046   jresult = (int)result;
67047   return jresult;
67048 }
67049
67050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
67051   int jresult ;
67052   int result;
67053
67054   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
67055   jresult = (int)result;
67056   return jresult;
67057 }
67058
67059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67060   void * jresult ;
67061   Dali::Toolkit::Control::Property *result = 0 ;
67062
67063   {
67064     try {
67065       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67066     } catch (std::out_of_range& e) {
67067       {
67068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67069       };
67070     } catch (std::exception& e) {
67071       {
67072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67073       };
67074     } catch (Dali::DaliException e) {
67075       {
67076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67077       };
67078     } catch (...) {
67079       {
67080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67081       };
67082     }
67083   }
67084
67085   jresult = (void *)result;
67086   return jresult;
67087 }
67088
67089
67090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67091   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67092
67093   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67094   {
67095     try {
67096       delete arg1;
67097     } catch (std::out_of_range& e) {
67098       {
67099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67100       };
67101     } catch (std::exception& e) {
67102       {
67103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67104       };
67105     } catch (Dali::DaliException e) {
67106       {
67107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67108       };
67109     } catch (...) {
67110       {
67111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67112       };
67113     }
67114   }
67115
67116 }
67117
67118
67119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67120   void * jresult ;
67121   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67122
67123   {
67124     try {
67125       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67126     } catch (std::out_of_range& e) {
67127       {
67128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67129       };
67130     } catch (std::exception& e) {
67131       {
67132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67133       };
67134     } catch (Dali::DaliException e) {
67135       {
67136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67137       };
67138     } catch (...) {
67139       {
67140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67141       };
67142     }
67143   }
67144
67145   jresult = (void *)result;
67146   return jresult;
67147 }
67148
67149
67150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67151   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67152
67153   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67154   {
67155     try {
67156       delete arg1;
67157     } catch (std::out_of_range& e) {
67158       {
67159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67160       };
67161     } catch (std::exception& e) {
67162       {
67163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67164       };
67165     } catch (Dali::DaliException e) {
67166       {
67167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67168       };
67169     } catch (...) {
67170       {
67171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67172       };
67173     }
67174   }
67175
67176 }
67177
67178
67179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67180   void * jresult ;
67181   Dali::Toolkit::Control result;
67182
67183   {
67184     try {
67185       result = Dali::Toolkit::Control::New();
67186     } catch (std::out_of_range& e) {
67187       {
67188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67189       };
67190     } catch (std::exception& e) {
67191       {
67192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67193       };
67194     } catch (Dali::DaliException e) {
67195       {
67196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67197       };
67198     } catch (...) {
67199       {
67200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67201       };
67202     }
67203   }
67204
67205   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67206   return jresult;
67207 }
67208
67209
67210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67211   void * jresult ;
67212   Dali::Toolkit::Control *result = 0 ;
67213
67214   {
67215     try {
67216       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67217     } catch (std::out_of_range& e) {
67218       {
67219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67220       };
67221     } catch (std::exception& e) {
67222       {
67223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67224       };
67225     } catch (Dali::DaliException e) {
67226       {
67227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67228       };
67229     } catch (...) {
67230       {
67231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67232       };
67233     }
67234   }
67235
67236   jresult = (void *)result;
67237   return jresult;
67238 }
67239
67240
67241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67242   void * jresult ;
67243   Dali::Toolkit::Control *arg1 = 0 ;
67244   Dali::Toolkit::Control *result = 0 ;
67245
67246   arg1 = (Dali::Toolkit::Control *)jarg1;
67247   if (!arg1) {
67248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67249     return 0;
67250   }
67251   {
67252     try {
67253       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67254     } catch (std::out_of_range& e) {
67255       {
67256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67257       };
67258     } catch (std::exception& e) {
67259       {
67260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67261       };
67262     } catch (Dali::DaliException e) {
67263       {
67264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67265       };
67266     } catch (...) {
67267       {
67268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67269       };
67270     }
67271   }
67272
67273   jresult = (void *)result;
67274   return jresult;
67275 }
67276
67277
67278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67279   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67280
67281   arg1 = (Dali::Toolkit::Control *)jarg1;
67282   {
67283     try {
67284       delete arg1;
67285     } catch (std::out_of_range& e) {
67286       {
67287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67288       };
67289     } catch (std::exception& e) {
67290       {
67291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67292       };
67293     } catch (Dali::DaliException e) {
67294       {
67295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67296       };
67297     } catch (...) {
67298       {
67299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67300       };
67301     }
67302   }
67303
67304 }
67305
67306
67307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67308   void * jresult ;
67309   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67310   Dali::Toolkit::Control *arg2 = 0 ;
67311   Dali::Toolkit::Control *result = 0 ;
67312
67313   arg1 = (Dali::Toolkit::Control *)jarg1;
67314   arg2 = (Dali::Toolkit::Control *)jarg2;
67315   if (!arg2) {
67316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67317     return 0;
67318   }
67319   {
67320     try {
67321       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67322     } catch (std::out_of_range& e) {
67323       {
67324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67325       };
67326     } catch (std::exception& e) {
67327       {
67328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67329       };
67330     } catch (Dali::DaliException e) {
67331       {
67332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67333       };
67334     } catch (...) {
67335       {
67336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67337       };
67338     }
67339   }
67340
67341   jresult = (void *)result;
67342   return jresult;
67343 }
67344
67345
67346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67347   void * jresult ;
67348   Dali::BaseHandle arg1 ;
67349   Dali::BaseHandle *argp1 ;
67350   Dali::Toolkit::Control result;
67351
67352   argp1 = (Dali::BaseHandle *)jarg1;
67353   if (!argp1) {
67354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67355     return 0;
67356   }
67357   arg1 = *argp1;
67358   {
67359     try {
67360       result = Dali::Toolkit::Control::DownCast(arg1);
67361     } catch (std::out_of_range& e) {
67362       {
67363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67364       };
67365     } catch (std::exception& e) {
67366       {
67367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67368       };
67369     } catch (Dali::DaliException e) {
67370       {
67371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67372       };
67373     } catch (...) {
67374       {
67375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67376       };
67377     }
67378   }
67379
67380   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67381   return jresult;
67382 }
67383
67384
67385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67386   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67387
67388   arg1 = (Dali::Toolkit::Control *)jarg1;
67389   {
67390     try {
67391       (arg1)->SetKeyInputFocus();
67392     } catch (std::out_of_range& e) {
67393       {
67394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67395       };
67396     } catch (std::exception& e) {
67397       {
67398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67399       };
67400     } catch (Dali::DaliException e) {
67401       {
67402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67403       };
67404     } catch (...) {
67405       {
67406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67407       };
67408     }
67409   }
67410
67411 }
67412
67413
67414 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67415   unsigned int jresult ;
67416   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67417   bool result;
67418
67419   arg1 = (Dali::Toolkit::Control *)jarg1;
67420   {
67421     try {
67422       result = (bool)(arg1)->HasKeyInputFocus();
67423     } catch (std::out_of_range& e) {
67424       {
67425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67426       };
67427     } catch (std::exception& e) {
67428       {
67429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67430       };
67431     } catch (Dali::DaliException e) {
67432       {
67433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67434       };
67435     } catch (...) {
67436       {
67437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67438       };
67439     }
67440   }
67441
67442   jresult = result;
67443   return jresult;
67444 }
67445
67446
67447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67448   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67449
67450   arg1 = (Dali::Toolkit::Control *)jarg1;
67451   {
67452     try {
67453       (arg1)->ClearKeyInputFocus();
67454     } catch (std::out_of_range& e) {
67455       {
67456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67457       };
67458     } catch (std::exception& e) {
67459       {
67460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67461       };
67462     } catch (Dali::DaliException e) {
67463       {
67464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67465       };
67466     } catch (...) {
67467       {
67468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67469       };
67470     }
67471   }
67472
67473 }
67474
67475
67476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67477   void * jresult ;
67478   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67479   Dali::PinchGestureDetector result;
67480
67481   arg1 = (Dali::Toolkit::Control *)jarg1;
67482   {
67483     try {
67484       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67485     } catch (std::out_of_range& e) {
67486       {
67487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67488       };
67489     } catch (std::exception& e) {
67490       {
67491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67492       };
67493     } catch (Dali::DaliException e) {
67494       {
67495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67496       };
67497     } catch (...) {
67498       {
67499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67500       };
67501     }
67502   }
67503
67504   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67505   return jresult;
67506 }
67507
67508
67509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67510   void * jresult ;
67511   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67512   Dali::PanGestureDetector result;
67513
67514   arg1 = (Dali::Toolkit::Control *)jarg1;
67515   {
67516     try {
67517       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67518     } catch (std::out_of_range& e) {
67519       {
67520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67521       };
67522     } catch (std::exception& e) {
67523       {
67524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67525       };
67526     } catch (Dali::DaliException e) {
67527       {
67528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67529       };
67530     } catch (...) {
67531       {
67532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67533       };
67534     }
67535   }
67536
67537   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67538   return jresult;
67539 }
67540
67541
67542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67543   void * jresult ;
67544   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67545   Dali::TapGestureDetector result;
67546
67547   arg1 = (Dali::Toolkit::Control *)jarg1;
67548   {
67549     try {
67550       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67551     } catch (std::out_of_range& e) {
67552       {
67553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67554       };
67555     } catch (std::exception& e) {
67556       {
67557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67558       };
67559     } catch (Dali::DaliException e) {
67560       {
67561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67562       };
67563     } catch (...) {
67564       {
67565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67566       };
67567     }
67568   }
67569
67570   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67571   return jresult;
67572 }
67573
67574
67575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67576   void * jresult ;
67577   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67578   Dali::LongPressGestureDetector result;
67579
67580   arg1 = (Dali::Toolkit::Control *)jarg1;
67581   {
67582     try {
67583       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67584     } catch (std::out_of_range& e) {
67585       {
67586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67587       };
67588     } catch (std::exception& e) {
67589       {
67590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67591       };
67592     } catch (Dali::DaliException e) {
67593       {
67594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67595       };
67596     } catch (...) {
67597       {
67598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67599       };
67600     }
67601   }
67602
67603   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
67604   return jresult;
67605 }
67606
67607
67608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
67609   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67610   std::string *arg2 = 0 ;
67611
67612   arg1 = (Dali::Toolkit::Control *)jarg1;
67613   if (!jarg2) {
67614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67615     return ;
67616   }
67617   std::string arg2_str(jarg2);
67618   arg2 = &arg2_str;
67619   {
67620     try {
67621       (arg1)->SetStyleName((std::string const &)*arg2);
67622     } catch (std::out_of_range& e) {
67623       {
67624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67625       };
67626     } catch (std::exception& e) {
67627       {
67628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67629       };
67630     } catch (Dali::DaliException e) {
67631       {
67632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67633       };
67634     } catch (...) {
67635       {
67636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67637       };
67638     }
67639   }
67640
67641
67642   //argout typemap for const std::string&
67643
67644 }
67645
67646
67647 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
67648   char * jresult ;
67649   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67650   std::string *result = 0 ;
67651
67652   arg1 = (Dali::Toolkit::Control *)jarg1;
67653   {
67654     try {
67655       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
67656     } catch (std::out_of_range& e) {
67657       {
67658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67659       };
67660     } catch (std::exception& e) {
67661       {
67662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67663       };
67664     } catch (Dali::DaliException e) {
67665       {
67666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67667       };
67668     } catch (...) {
67669       {
67670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67671       };
67672     }
67673   }
67674
67675   jresult = SWIG_csharp_string_callback(result->c_str());
67676   return jresult;
67677 }
67678
67679
67680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
67681   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67682   Dali::Vector4 *arg2 = 0 ;
67683
67684   arg1 = (Dali::Toolkit::Control *)jarg1;
67685   arg2 = (Dali::Vector4 *)jarg2;
67686   if (!arg2) {
67687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67688     return ;
67689   }
67690   {
67691     try {
67692       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
67693     } catch (std::out_of_range& e) {
67694       {
67695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67696       };
67697     } catch (std::exception& e) {
67698       {
67699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67700       };
67701     } catch (Dali::DaliException e) {
67702       {
67703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67704       };
67705     } catch (...) {
67706       {
67707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67708       };
67709     }
67710   }
67711
67712 }
67713
67714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
67715   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67716
67717   arg1 = (Dali::Toolkit::Control *)jarg1;
67718   {
67719     try {
67720       (arg1)->ClearBackground();
67721     } catch (std::out_of_range& e) {
67722       {
67723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67724       };
67725     } catch (std::exception& e) {
67726       {
67727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67728       };
67729     } catch (Dali::DaliException e) {
67730       {
67731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67732       };
67733     } catch (...) {
67734       {
67735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67736       };
67737     }
67738   }
67739
67740 }
67741
67742
67743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
67744   void * jresult ;
67745   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67746   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
67747
67748   arg1 = (Dali::Toolkit::Control *)jarg1;
67749   {
67750     try {
67751       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
67752     } catch (std::out_of_range& e) {
67753       {
67754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67755       };
67756     } catch (std::exception& e) {
67757       {
67758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67759       };
67760     } catch (Dali::DaliException e) {
67761       {
67762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67763       };
67764     } catch (...) {
67765       {
67766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67767       };
67768     }
67769   }
67770
67771   jresult = (void *)result;
67772   return jresult;
67773 }
67774
67775
67776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
67777   void * jresult ;
67778   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67779   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67780
67781   arg1 = (Dali::Toolkit::Control *)jarg1;
67782   {
67783     try {
67784       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
67785     } catch (std::out_of_range& e) {
67786       {
67787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67788       };
67789     } catch (std::exception& e) {
67790       {
67791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67792       };
67793     } catch (Dali::DaliException e) {
67794       {
67795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67796       };
67797     } catch (...) {
67798       {
67799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67800       };
67801     }
67802   }
67803
67804   jresult = (void *)result;
67805   return jresult;
67806 }
67807
67808
67809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
67810   void * jresult ;
67811   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67812   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67813
67814   arg1 = (Dali::Toolkit::Control *)jarg1;
67815   {
67816     try {
67817       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
67818     } catch (std::out_of_range& e) {
67819       {
67820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67821       };
67822     } catch (std::exception& e) {
67823       {
67824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67825       };
67826     } catch (Dali::DaliException e) {
67827       {
67828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67829       };
67830     } catch (...) {
67831       {
67832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67833       };
67834     }
67835   }
67836
67837   jresult = (void *)result;
67838   return jresult;
67839 }
67840
67841
67842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
67843   void * jresult ;
67844   Dali::Toolkit::Internal::Control *arg1 = 0 ;
67845   Dali::Toolkit::Control *result = 0 ;
67846
67847   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67848   if (!arg1) {
67849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
67850     return 0;
67851   }
67852   {
67853     try {
67854       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
67855     } catch (std::out_of_range& e) {
67856       {
67857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67858       };
67859     } catch (std::exception& e) {
67860       {
67861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67862       };
67863     } catch (Dali::DaliException e) {
67864       {
67865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67866       };
67867     } catch (...) {
67868       {
67869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67870       };
67871     }
67872   }
67873
67874   jresult = (void *)result;
67875   return jresult;
67876 }
67877
67878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
67879 {
67880   int jresult;
67881   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67882   arg1 = (Dali::Toolkit::Control *)jarg1;
67883
67884   if (!arg1) {
67885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67886     return 0;
67887   }
67888
67889   Dali::Property::Index arg2 = 0 ;
67890   arg2 = (Dali::Property::Index)jarg2;
67891
67892   Toolkit::Visual::ResourceStatus result;
67893   {
67894     try {
67895       result = arg1->GetVisualResourceStatus(arg2);
67896     } catch (std::out_of_range& e) {
67897       {
67898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67899       };
67900     } catch (std::exception& e) {
67901       {
67902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67903       };
67904     } catch (...) {
67905       {
67906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67907       };
67908     }
67909   }
67910   jresult = (int)(result);
67911   return jresult;
67912 }
67913
67914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
67915 {
67916   void * jresult;
67917   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67918   arg1 = (Dali::Toolkit::Control *)jarg1;
67919
67920   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
67921
67922   Dali::Toolkit::TransitionData *arg2 = 0 ;
67923   Dali::Animation result;
67924
67925   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
67926   if (!arg2) {
67927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
67928     return 0;
67929   }
67930   {
67931     try {
67932       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
67933     } catch (std::out_of_range& e) {
67934       {
67935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67936       };
67937     } catch (std::exception& e) {
67938       {
67939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67940       };
67941     } catch (Dali::DaliException e) {
67942       {
67943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67944       };
67945     } catch (...) {
67946       {
67947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67948       };
67949     }
67950   }
67951
67952   jresult = new Dali::Animation((const Dali::Animation &)result);
67953   return jresult;
67954 }
67955
67956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
67957 {
67958   Dali::Toolkit::Control arg1;
67959   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
67960
67961   if (!argp1) {
67962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67963   }
67964   arg1 = *argp1;
67965
67966   Dali::Property::Index arg2 = 0 ;
67967   arg2 = (Dali::Property::Index)jarg2;
67968
67969   Dali::Property::Index arg3 = 0 ;
67970   arg3 = (Dali::Property::Index)jarg3;
67971
67972   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
67973
67974   {
67975     try {
67976       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
67977     } catch (std::out_of_range& e) {
67978       {
67979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67980       };
67981     } catch (std::exception& e) {
67982       {
67983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67984       };
67985     } catch (...) {
67986       {
67987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67988       };
67989     }
67990   }
67991
67992
67993 }
67994
67995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
67996   void * jresult ;
67997   Dali::Toolkit::Control *arg1 = 0 ;
67998   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
67999
68000   arg1 = (Dali::Toolkit::Control *)jarg1;
68001   if (!arg1) {
68002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68003     return 0;
68004   }
68005   {
68006     try {
68007       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68008     } catch (std::out_of_range& e) {
68009       {
68010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68011       };
68012     } catch (std::exception& e) {
68013       {
68014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68015       };
68016     } catch (Dali::DaliException e) {
68017       {
68018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68019       };
68020     } catch (...) {
68021       {
68022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68023       };
68024     }
68025   }
68026
68027   jresult = (void *)result;
68028   return jresult;
68029 }
68030
68031
68032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68033   unsigned int jresult ;
68034   Dali::Toolkit::Control *arg1 = 0 ;
68035   bool result;
68036
68037   arg1 = (Dali::Toolkit::Control *)jarg1;
68038   if (!arg1) {
68039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68040     return 0;
68041   }
68042   {
68043     try {
68044       result = (bool)arg1->IsResourceReady();
68045     } catch (std::out_of_range& e) {
68046       {
68047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68048       };
68049     } catch (std::exception& e) {
68050       {
68051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68052       };
68053     } catch (Dali::DaliException e) {
68054       {
68055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68056       };
68057     } catch (...) {
68058       {
68059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68060       };
68061     }
68062   }
68063
68064   jresult = result;
68065   return jresult;
68066 }
68067
68068
68069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68070   void * jresult ;
68071   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68072
68073   {
68074     try {
68075       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68076     } catch (std::out_of_range& e) {
68077       {
68078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68079       };
68080     } catch (std::exception& e) {
68081       {
68082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68083       };
68084     } catch (Dali::DaliException e) {
68085       {
68086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68087       };
68088     } catch (...) {
68089       {
68090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68091       };
68092     }
68093   }
68094
68095   jresult = (void *)result;
68096   return jresult;
68097 }
68098
68099
68100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68101   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68102
68103   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68104   {
68105     try {
68106       delete arg1;
68107     } catch (std::out_of_range& e) {
68108       {
68109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68110       };
68111     } catch (std::exception& e) {
68112       {
68113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68114       };
68115     } catch (Dali::DaliException e) {
68116       {
68117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68118       };
68119     } catch (...) {
68120       {
68121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68122       };
68123     }
68124   }
68125
68126 }
68127
68128
68129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68130   void * jresult ;
68131   Dali::Toolkit::KeyInputFocusManager result;
68132
68133   {
68134     try {
68135       result = Dali::Toolkit::KeyInputFocusManager::Get();
68136     } catch (std::out_of_range& e) {
68137       {
68138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68139       };
68140     } catch (std::exception& e) {
68141       {
68142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68143       };
68144     } catch (Dali::DaliException e) {
68145       {
68146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68147       };
68148     } catch (...) {
68149       {
68150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68151       };
68152     }
68153   }
68154
68155   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68156   return jresult;
68157 }
68158
68159
68160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68161   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68162   Dali::Toolkit::Control arg2 ;
68163   Dali::Toolkit::Control *argp2 ;
68164
68165   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68166   argp2 = (Dali::Toolkit::Control *)jarg2;
68167   if (!argp2) {
68168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68169     return ;
68170   }
68171   arg2 = *argp2;
68172   {
68173     try {
68174       (arg1)->SetFocus(arg2);
68175     } catch (std::out_of_range& e) {
68176       {
68177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68178       };
68179     } catch (std::exception& e) {
68180       {
68181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68182       };
68183     } catch (Dali::DaliException e) {
68184       {
68185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68186       };
68187     } catch (...) {
68188       {
68189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68190       };
68191     }
68192   }
68193
68194 }
68195
68196
68197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68198   void * jresult ;
68199   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68200   Dali::Toolkit::Control result;
68201
68202   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68203   {
68204     try {
68205       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68206     } catch (std::out_of_range& e) {
68207       {
68208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68209       };
68210     } catch (std::exception& e) {
68211       {
68212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68213       };
68214     } catch (Dali::DaliException e) {
68215       {
68216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68217       };
68218     } catch (...) {
68219       {
68220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68221       };
68222     }
68223   }
68224
68225   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68226   return jresult;
68227 }
68228
68229
68230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68231   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68232   Dali::Toolkit::Control arg2 ;
68233   Dali::Toolkit::Control *argp2 ;
68234
68235   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68236   argp2 = (Dali::Toolkit::Control *)jarg2;
68237   if (!argp2) {
68238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68239     return ;
68240   }
68241   arg2 = *argp2;
68242   {
68243     try {
68244       (arg1)->RemoveFocus(arg2);
68245     } catch (std::out_of_range& e) {
68246       {
68247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68248       };
68249     } catch (std::exception& e) {
68250       {
68251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68252       };
68253     } catch (Dali::DaliException e) {
68254       {
68255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68256       };
68257     } catch (...) {
68258       {
68259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68260       };
68261     }
68262   }
68263
68264 }
68265
68266
68267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68268   void * jresult ;
68269   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68270   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68271
68272   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68273   {
68274     try {
68275       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68276     } catch (std::out_of_range& e) {
68277       {
68278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68279       };
68280     } catch (std::exception& e) {
68281       {
68282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68283       };
68284     } catch (Dali::DaliException e) {
68285       {
68286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68287       };
68288     } catch (...) {
68289       {
68290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68291       };
68292     }
68293   }
68294
68295   jresult = (void *)result;
68296   return jresult;
68297 }
68298
68299
68300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68301   void * jresult ;
68302   Dali::Toolkit::Alignment::Padding *result = 0 ;
68303
68304   {
68305     try {
68306       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68307     } catch (std::out_of_range& e) {
68308       {
68309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68310       };
68311     } catch (std::exception& e) {
68312       {
68313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68314       };
68315     } catch (Dali::DaliException e) {
68316       {
68317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68318       };
68319     } catch (...) {
68320       {
68321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68322       };
68323     }
68324   }
68325
68326   jresult = (void *)result;
68327   return jresult;
68328 }
68329
68330
68331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68332   void * jresult ;
68333   float arg1 ;
68334   float arg2 ;
68335   float arg3 ;
68336   float arg4 ;
68337   Dali::Toolkit::Alignment::Padding *result = 0 ;
68338
68339   arg1 = (float)jarg1;
68340   arg2 = (float)jarg2;
68341   arg3 = (float)jarg3;
68342   arg4 = (float)jarg4;
68343   {
68344     try {
68345       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68346     } catch (std::out_of_range& e) {
68347       {
68348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68349       };
68350     } catch (std::exception& e) {
68351       {
68352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68353       };
68354     } catch (Dali::DaliException e) {
68355       {
68356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68357       };
68358     } catch (...) {
68359       {
68360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68361       };
68362     }
68363   }
68364
68365   jresult = (void *)result;
68366   return jresult;
68367 }
68368
68369
68370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68371   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68372   float arg2 ;
68373
68374   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68375   arg2 = (float)jarg2;
68376   if (arg1) (arg1)->left = arg2;
68377 }
68378
68379
68380 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68381   float jresult ;
68382   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68383   float result;
68384
68385   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68386   result = (float) ((arg1)->left);
68387   jresult = result;
68388   return jresult;
68389 }
68390
68391
68392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68393   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68394   float arg2 ;
68395
68396   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68397   arg2 = (float)jarg2;
68398   if (arg1) (arg1)->right = arg2;
68399 }
68400
68401
68402 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68403   float jresult ;
68404   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68405   float result;
68406
68407   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68408   result = (float) ((arg1)->right);
68409   jresult = result;
68410   return jresult;
68411 }
68412
68413
68414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68415   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68416   float arg2 ;
68417
68418   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68419   arg2 = (float)jarg2;
68420   if (arg1) (arg1)->top = arg2;
68421 }
68422
68423
68424 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68425   float jresult ;
68426   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68427   float result;
68428
68429   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68430   result = (float) ((arg1)->top);
68431   jresult = result;
68432   return jresult;
68433 }
68434
68435
68436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68437   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68438   float arg2 ;
68439
68440   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68441   arg2 = (float)jarg2;
68442   if (arg1) (arg1)->bottom = arg2;
68443 }
68444
68445
68446 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68447   float jresult ;
68448   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68449   float result;
68450
68451   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68452   result = (float) ((arg1)->bottom);
68453   jresult = result;
68454   return jresult;
68455 }
68456
68457
68458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68459   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68460
68461   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68462   {
68463     try {
68464       delete arg1;
68465     } catch (std::out_of_range& e) {
68466       {
68467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68468       };
68469     } catch (std::exception& e) {
68470       {
68471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68472       };
68473     } catch (Dali::DaliException e) {
68474       {
68475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68476       };
68477     } catch (...) {
68478       {
68479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68480       };
68481     }
68482   }
68483
68484 }
68485
68486
68487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68488   void * jresult ;
68489   Dali::Toolkit::Alignment *result = 0 ;
68490
68491   {
68492     try {
68493       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68494     } catch (std::out_of_range& e) {
68495       {
68496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68497       };
68498     } catch (std::exception& e) {
68499       {
68500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68501       };
68502     } catch (Dali::DaliException e) {
68503       {
68504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68505       };
68506     } catch (...) {
68507       {
68508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68509       };
68510     }
68511   }
68512
68513   jresult = (void *)result;
68514   return jresult;
68515 }
68516
68517
68518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68519   void * jresult ;
68520   Dali::Toolkit::Alignment::Type arg1 ;
68521   Dali::Toolkit::Alignment::Type arg2 ;
68522   Dali::Toolkit::Alignment result;
68523
68524   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68525   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68526   {
68527     try {
68528       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68529     } catch (std::out_of_range& e) {
68530       {
68531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68532       };
68533     } catch (std::exception& e) {
68534       {
68535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68536       };
68537     } catch (Dali::DaliException e) {
68538       {
68539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68540       };
68541     } catch (...) {
68542       {
68543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68544       };
68545     }
68546   }
68547
68548   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68549   return jresult;
68550 }
68551
68552
68553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
68554   void * jresult ;
68555   Dali::Toolkit::Alignment::Type arg1 ;
68556   Dali::Toolkit::Alignment result;
68557
68558   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68559   {
68560     try {
68561       result = Dali::Toolkit::Alignment::New(arg1);
68562     } catch (std::out_of_range& e) {
68563       {
68564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68565       };
68566     } catch (std::exception& e) {
68567       {
68568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68569       };
68570     } catch (Dali::DaliException e) {
68571       {
68572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68573       };
68574     } catch (...) {
68575       {
68576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68577       };
68578     }
68579   }
68580
68581   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68582   return jresult;
68583 }
68584
68585
68586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
68587   void * jresult ;
68588   Dali::Toolkit::Alignment result;
68589
68590   {
68591     try {
68592       result = Dali::Toolkit::Alignment::New();
68593     } catch (std::out_of_range& e) {
68594       {
68595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68596       };
68597     } catch (std::exception& e) {
68598       {
68599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68600       };
68601     } catch (Dali::DaliException e) {
68602       {
68603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68604       };
68605     } catch (...) {
68606       {
68607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68608       };
68609     }
68610   }
68611
68612   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68613   return jresult;
68614 }
68615
68616
68617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
68618   void * jresult ;
68619   Dali::Toolkit::Alignment *arg1 = 0 ;
68620   Dali::Toolkit::Alignment *result = 0 ;
68621
68622   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68623   if (!arg1) {
68624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68625     return 0;
68626   }
68627   {
68628     try {
68629       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
68630     } catch (std::out_of_range& e) {
68631       {
68632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68633       };
68634     } catch (std::exception& e) {
68635       {
68636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68637       };
68638     } catch (Dali::DaliException e) {
68639       {
68640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68641       };
68642     } catch (...) {
68643       {
68644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68645       };
68646     }
68647   }
68648
68649   jresult = (void *)result;
68650   return jresult;
68651 }
68652
68653
68654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
68655   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68656
68657   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68658   {
68659     try {
68660       delete arg1;
68661     } catch (std::out_of_range& e) {
68662       {
68663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68664       };
68665     } catch (std::exception& e) {
68666       {
68667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68668       };
68669     } catch (Dali::DaliException e) {
68670       {
68671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68672       };
68673     } catch (...) {
68674       {
68675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68676       };
68677     }
68678   }
68679
68680 }
68681
68682
68683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
68684   void * jresult ;
68685   Dali::BaseHandle arg1 ;
68686   Dali::BaseHandle *argp1 ;
68687   Dali::Toolkit::Alignment result;
68688
68689   argp1 = (Dali::BaseHandle *)jarg1;
68690   if (!argp1) {
68691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68692     return 0;
68693   }
68694   arg1 = *argp1;
68695   {
68696     try {
68697       result = Dali::Toolkit::Alignment::DownCast(arg1);
68698     } catch (std::out_of_range& e) {
68699       {
68700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68701       };
68702     } catch (std::exception& e) {
68703       {
68704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68705       };
68706     } catch (Dali::DaliException e) {
68707       {
68708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68709       };
68710     } catch (...) {
68711       {
68712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68713       };
68714     }
68715   }
68716
68717   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68718   return jresult;
68719 }
68720
68721
68722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
68723   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68724   Dali::Toolkit::Alignment::Type arg2 ;
68725
68726   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68727   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68728   {
68729     try {
68730       (arg1)->SetAlignmentType(arg2);
68731     } catch (std::out_of_range& e) {
68732       {
68733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68734       };
68735     } catch (std::exception& e) {
68736       {
68737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68738       };
68739     } catch (Dali::DaliException e) {
68740       {
68741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68742       };
68743     } catch (...) {
68744       {
68745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68746       };
68747     }
68748   }
68749
68750 }
68751
68752
68753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
68754   int jresult ;
68755   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68756   Dali::Toolkit::Alignment::Type result;
68757
68758   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68759   {
68760     try {
68761       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
68762     } catch (std::out_of_range& e) {
68763       {
68764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68765       };
68766     } catch (std::exception& e) {
68767       {
68768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68769       };
68770     } catch (Dali::DaliException e) {
68771       {
68772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68773       };
68774     } catch (...) {
68775       {
68776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68777       };
68778     }
68779   }
68780
68781   jresult = (int)result;
68782   return jresult;
68783 }
68784
68785
68786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
68787   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68788   Dali::Toolkit::Alignment::Scaling arg2 ;
68789
68790   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68791   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
68792   {
68793     try {
68794       (arg1)->SetScaling(arg2);
68795     } catch (std::out_of_range& e) {
68796       {
68797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68798       };
68799     } catch (std::exception& e) {
68800       {
68801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68802       };
68803     } catch (Dali::DaliException e) {
68804       {
68805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68806       };
68807     } catch (...) {
68808       {
68809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68810       };
68811     }
68812   }
68813
68814 }
68815
68816
68817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
68818   int jresult ;
68819   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68820   Dali::Toolkit::Alignment::Scaling result;
68821
68822   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68823   {
68824     try {
68825       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
68826     } catch (std::out_of_range& e) {
68827       {
68828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68829       };
68830     } catch (std::exception& e) {
68831       {
68832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68833       };
68834     } catch (Dali::DaliException e) {
68835       {
68836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68837       };
68838     } catch (...) {
68839       {
68840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68841       };
68842     }
68843   }
68844
68845   jresult = (int)result;
68846   return jresult;
68847 }
68848
68849
68850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
68851   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68852   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
68853
68854   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68855   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
68856   if (!arg2) {
68857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
68858     return ;
68859   }
68860   {
68861     try {
68862       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
68863     } catch (std::out_of_range& e) {
68864       {
68865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68866       };
68867     } catch (std::exception& e) {
68868       {
68869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68870       };
68871     } catch (Dali::DaliException e) {
68872       {
68873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68874       };
68875     } catch (...) {
68876       {
68877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68878       };
68879     }
68880   }
68881
68882 }
68883
68884
68885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
68886   void * jresult ;
68887   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68888   Dali::Toolkit::Alignment::Padding *result = 0 ;
68889
68890   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68891   {
68892     try {
68893       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
68894     } catch (std::out_of_range& e) {
68895       {
68896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68897       };
68898     } catch (std::exception& e) {
68899       {
68900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68901       };
68902     } catch (Dali::DaliException e) {
68903       {
68904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68905       };
68906     } catch (...) {
68907       {
68908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68909       };
68910     }
68911   }
68912
68913   jresult = (void *)result;
68914   return jresult;
68915 }
68916
68917
68918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
68919   void * jresult ;
68920   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68921   Dali::Toolkit::Alignment *arg2 = 0 ;
68922   Dali::Toolkit::Alignment *result = 0 ;
68923
68924   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68925   arg2 = (Dali::Toolkit::Alignment *)jarg2;
68926   if (!arg2) {
68927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68928     return 0;
68929   }
68930   {
68931     try {
68932       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
68933     } catch (std::out_of_range& e) {
68934       {
68935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68936       };
68937     } catch (std::exception& e) {
68938       {
68939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68940       };
68941     } catch (Dali::DaliException e) {
68942       {
68943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68944       };
68945     } catch (...) {
68946       {
68947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68948       };
68949     }
68950   }
68951
68952   jresult = (void *)result;
68953   return jresult;
68954 }
68955
68956
68957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
68958   int jresult ;
68959   int result;
68960
68961   result = (int)Dali::Toolkit::Button::Property::DISABLED;
68962   jresult = (int)result;
68963   return jresult;
68964 }
68965
68966
68967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
68968   int jresult ;
68969   int result;
68970
68971   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
68972   jresult = (int)result;
68973   return jresult;
68974 }
68975
68976
68977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
68978   int jresult ;
68979   int result;
68980
68981   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
68982   jresult = (int)result;
68983   return jresult;
68984 }
68985
68986
68987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
68988   int jresult ;
68989   int result;
68990
68991   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
68992   jresult = (int)result;
68993   return jresult;
68994 }
68995
68996
68997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
68998   int jresult ;
68999   int result;
69000
69001   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69002   jresult = (int)result;
69003   return jresult;
69004 }
69005
69006
69007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69008   int jresult ;
69009   int result;
69010
69011   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69012   jresult = (int)result;
69013   return jresult;
69014 }
69015
69016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69017   int jresult ;
69018   int result;
69019
69020   result = (int)Dali::Toolkit::Button::Property::LABEL;
69021   jresult = (int)result;
69022   return jresult;
69023 }
69024
69025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69026   void * jresult ;
69027   Dali::Toolkit::Button::Property *result = 0 ;
69028
69029   {
69030     try {
69031       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69032     } catch (std::out_of_range& e) {
69033       {
69034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69035       };
69036     } catch (std::exception& e) {
69037       {
69038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69039       };
69040     } catch (Dali::DaliException e) {
69041       {
69042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69043       };
69044     } catch (...) {
69045       {
69046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69047       };
69048     }
69049   }
69050
69051   jresult = (void *)result;
69052   return jresult;
69053 }
69054
69055
69056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69057   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69058
69059   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69060   {
69061     try {
69062       delete arg1;
69063     } catch (std::out_of_range& e) {
69064       {
69065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69066       };
69067     } catch (std::exception& e) {
69068       {
69069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69070       };
69071     } catch (Dali::DaliException e) {
69072       {
69073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69074       };
69075     } catch (...) {
69076       {
69077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69078       };
69079     }
69080   }
69081
69082 }
69083
69084
69085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69086   void * jresult ;
69087   Dali::Toolkit::Button *result = 0 ;
69088
69089   {
69090     try {
69091       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69092     } catch (std::out_of_range& e) {
69093       {
69094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69095       };
69096     } catch (std::exception& e) {
69097       {
69098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69099       };
69100     } catch (Dali::DaliException e) {
69101       {
69102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69103       };
69104     } catch (...) {
69105       {
69106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69107       };
69108     }
69109   }
69110
69111   jresult = (void *)result;
69112   return jresult;
69113 }
69114
69115
69116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69117   void * jresult ;
69118   Dali::Toolkit::Button *arg1 = 0 ;
69119   Dali::Toolkit::Button *result = 0 ;
69120
69121   arg1 = (Dali::Toolkit::Button *)jarg1;
69122   if (!arg1) {
69123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69124     return 0;
69125   }
69126   {
69127     try {
69128       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69129     } catch (std::out_of_range& e) {
69130       {
69131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69132       };
69133     } catch (std::exception& e) {
69134       {
69135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69136       };
69137     } catch (Dali::DaliException e) {
69138       {
69139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69140       };
69141     } catch (...) {
69142       {
69143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69144       };
69145     }
69146   }
69147
69148   jresult = (void *)result;
69149   return jresult;
69150 }
69151
69152
69153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69154   void * jresult ;
69155   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69156   Dali::Toolkit::Button *arg2 = 0 ;
69157   Dali::Toolkit::Button *result = 0 ;
69158
69159   arg1 = (Dali::Toolkit::Button *)jarg1;
69160   arg2 = (Dali::Toolkit::Button *)jarg2;
69161   if (!arg2) {
69162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69163     return 0;
69164   }
69165   {
69166     try {
69167       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69168     } catch (std::out_of_range& e) {
69169       {
69170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69171       };
69172     } catch (std::exception& e) {
69173       {
69174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69175       };
69176     } catch (Dali::DaliException e) {
69177       {
69178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69179       };
69180     } catch (...) {
69181       {
69182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69183       };
69184     }
69185   }
69186
69187   jresult = (void *)result;
69188   return jresult;
69189 }
69190
69191
69192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69193   void * jresult ;
69194   Dali::BaseHandle arg1 ;
69195   Dali::BaseHandle *argp1 ;
69196   Dali::Toolkit::Button result;
69197
69198   argp1 = (Dali::BaseHandle *)jarg1;
69199   if (!argp1) {
69200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69201     return 0;
69202   }
69203   arg1 = *argp1;
69204   {
69205     try {
69206       result = Dali::Toolkit::Button::DownCast(arg1);
69207     } catch (std::out_of_range& e) {
69208       {
69209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69210       };
69211     } catch (std::exception& e) {
69212       {
69213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69214       };
69215     } catch (Dali::DaliException e) {
69216       {
69217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69218       };
69219     } catch (...) {
69220       {
69221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69222       };
69223     }
69224   }
69225
69226   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69227   return jresult;
69228 }
69229
69230
69231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69232   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69233
69234   arg1 = (Dali::Toolkit::Button *)jarg1;
69235   {
69236     try {
69237       delete arg1;
69238     } catch (std::out_of_range& e) {
69239       {
69240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69241       };
69242     } catch (std::exception& e) {
69243       {
69244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69245       };
69246     } catch (Dali::DaliException e) {
69247       {
69248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69249       };
69250     } catch (...) {
69251       {
69252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69253       };
69254     }
69255   }
69256
69257 }
69258
69259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
69260   void * jresult ;
69261   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69262   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69263
69264   arg1 = (Dali::Toolkit::Button *)jarg1;
69265   {
69266     try {
69267       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
69268     } catch (std::out_of_range& e) {
69269       {
69270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69271       };
69272     } catch (std::exception& e) {
69273       {
69274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69275       };
69276     } catch (Dali::DaliException e) {
69277       {
69278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69279       };
69280     } catch (...) {
69281       {
69282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69283       };
69284     }
69285   }
69286
69287   jresult = (void *)result;
69288   return jresult;
69289 }
69290
69291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
69292   void * jresult ;
69293   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69294   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69295
69296   arg1 = (Dali::Toolkit::Button *)jarg1;
69297   {
69298     try {
69299       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
69300     } catch (std::out_of_range& e) {
69301       {
69302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69303       };
69304     } catch (std::exception& e) {
69305       {
69306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69307       };
69308     } catch (Dali::DaliException e) {
69309       {
69310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69311       };
69312     } catch (...) {
69313       {
69314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69315       };
69316     }
69317   }
69318
69319   jresult = (void *)result;
69320   return jresult;
69321 }
69322
69323
69324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
69325   void * jresult ;
69326   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69327   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69328
69329   arg1 = (Dali::Toolkit::Button *)jarg1;
69330   {
69331     try {
69332       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
69333     } catch (std::out_of_range& e) {
69334       {
69335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69336       };
69337     } catch (std::exception& e) {
69338       {
69339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69340       };
69341     } catch (Dali::DaliException e) {
69342       {
69343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69344       };
69345     } catch (...) {
69346       {
69347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69348       };
69349     }
69350   }
69351
69352   jresult = (void *)result;
69353   return jresult;
69354 }
69355
69356
69357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
69358   void * jresult ;
69359   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69360   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69361
69362   arg1 = (Dali::Toolkit::Button *)jarg1;
69363   {
69364     try {
69365       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
69366     } catch (std::out_of_range& e) {
69367       {
69368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69369       };
69370     } catch (std::exception& e) {
69371       {
69372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69373       };
69374     } catch (Dali::DaliException e) {
69375       {
69376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69377       };
69378     } catch (...) {
69379       {
69380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69381       };
69382     }
69383   }
69384
69385   jresult = (void *)result;
69386   return jresult;
69387 }
69388
69389
69390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
69391   void * jresult ;
69392   Dali::Toolkit::CheckBoxButton *result = 0 ;
69393
69394   {
69395     try {
69396       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
69397     } catch (std::out_of_range& e) {
69398       {
69399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69400       };
69401     } catch (std::exception& e) {
69402       {
69403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69404       };
69405     } catch (Dali::DaliException e) {
69406       {
69407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69408       };
69409     } catch (...) {
69410       {
69411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69412       };
69413     }
69414   }
69415
69416   jresult = (void *)result;
69417   return jresult;
69418 }
69419
69420
69421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
69422   void * jresult ;
69423   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
69424   Dali::Toolkit::CheckBoxButton *result = 0 ;
69425
69426   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69427   if (!arg1) {
69428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69429     return 0;
69430   }
69431   {
69432     try {
69433       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
69434     } catch (std::out_of_range& e) {
69435       {
69436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69437       };
69438     } catch (std::exception& e) {
69439       {
69440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69441       };
69442     } catch (Dali::DaliException e) {
69443       {
69444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69445       };
69446     } catch (...) {
69447       {
69448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69449       };
69450     }
69451   }
69452
69453   jresult = (void *)result;
69454   return jresult;
69455 }
69456
69457
69458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
69459   void * jresult ;
69460   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69461   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
69462   Dali::Toolkit::CheckBoxButton *result = 0 ;
69463
69464   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69465   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
69466   if (!arg2) {
69467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69468     return 0;
69469   }
69470   {
69471     try {
69472       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
69473     } catch (std::out_of_range& e) {
69474       {
69475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69476       };
69477     } catch (std::exception& e) {
69478       {
69479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69480       };
69481     } catch (Dali::DaliException e) {
69482       {
69483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69484       };
69485     } catch (...) {
69486       {
69487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69488       };
69489     }
69490   }
69491
69492   jresult = (void *)result;
69493   return jresult;
69494 }
69495
69496
69497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
69498   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69499
69500   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69501   {
69502     try {
69503       delete arg1;
69504     } catch (std::out_of_range& e) {
69505       {
69506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69507       };
69508     } catch (std::exception& e) {
69509       {
69510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69511       };
69512     } catch (Dali::DaliException e) {
69513       {
69514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69515       };
69516     } catch (...) {
69517       {
69518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69519       };
69520     }
69521   }
69522
69523 }
69524
69525
69526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
69527   void * jresult ;
69528   Dali::Toolkit::CheckBoxButton result;
69529
69530   {
69531     try {
69532       result = Dali::Toolkit::CheckBoxButton::New();
69533     } catch (std::out_of_range& e) {
69534       {
69535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69536       };
69537     } catch (std::exception& e) {
69538       {
69539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69540       };
69541     } catch (Dali::DaliException e) {
69542       {
69543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69544       };
69545     } catch (...) {
69546       {
69547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69548       };
69549     }
69550   }
69551
69552   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
69553   return jresult;
69554 }
69555
69556
69557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
69558   void * jresult ;
69559   Dali::BaseHandle arg1 ;
69560   Dali::BaseHandle *argp1 ;
69561   Dali::Toolkit::CheckBoxButton result;
69562
69563   argp1 = (Dali::BaseHandle *)jarg1;
69564   if (!argp1) {
69565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69566     return 0;
69567   }
69568   arg1 = *argp1;
69569   {
69570     try {
69571       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
69572     } catch (std::out_of_range& e) {
69573       {
69574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69575       };
69576     } catch (std::exception& e) {
69577       {
69578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69579       };
69580     } catch (Dali::DaliException e) {
69581       {
69582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69583       };
69584     } catch (...) {
69585       {
69586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69587       };
69588     }
69589   }
69590
69591   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
69592   return jresult;
69593 }
69594
69595
69596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
69597   int jresult ;
69598   int result;
69599
69600   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
69601   jresult = (int)result;
69602   return jresult;
69603 }
69604
69605
69606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
69607   int jresult ;
69608   int result;
69609
69610   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
69611   jresult = (int)result;
69612   return jresult;
69613 }
69614
69615
69616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
69617   int jresult ;
69618   int result;
69619
69620   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
69621   jresult = (int)result;
69622   return jresult;
69623 }
69624
69625
69626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
69627   int jresult ;
69628   int result;
69629
69630   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
69631   jresult = (int)result;
69632   return jresult;
69633 }
69634
69635
69636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
69637   int jresult ;
69638   int result;
69639
69640   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
69641   jresult = (int)result;
69642   return jresult;
69643 }
69644
69645
69646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
69647   void * jresult ;
69648   Dali::Toolkit::PushButton::Property *result = 0 ;
69649
69650   {
69651     try {
69652       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
69653     } catch (std::out_of_range& e) {
69654       {
69655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69656       };
69657     } catch (std::exception& e) {
69658       {
69659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69660       };
69661     } catch (Dali::DaliException e) {
69662       {
69663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69664       };
69665     } catch (...) {
69666       {
69667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69668       };
69669     }
69670   }
69671
69672   jresult = (void *)result;
69673   return jresult;
69674 }
69675
69676
69677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
69678   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
69679
69680   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
69681   {
69682     try {
69683       delete arg1;
69684     } catch (std::out_of_range& e) {
69685       {
69686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69687       };
69688     } catch (std::exception& e) {
69689       {
69690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69691       };
69692     } catch (Dali::DaliException e) {
69693       {
69694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69695       };
69696     } catch (...) {
69697       {
69698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69699       };
69700     }
69701   }
69702
69703 }
69704
69705
69706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
69707   void * jresult ;
69708   Dali::Toolkit::PushButton *result = 0 ;
69709
69710   {
69711     try {
69712       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
69713     } catch (std::out_of_range& e) {
69714       {
69715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69716       };
69717     } catch (std::exception& e) {
69718       {
69719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69720       };
69721     } catch (Dali::DaliException e) {
69722       {
69723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69724       };
69725     } catch (...) {
69726       {
69727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69728       };
69729     }
69730   }
69731
69732   jresult = (void *)result;
69733   return jresult;
69734 }
69735
69736
69737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
69738   void * jresult ;
69739   Dali::Toolkit::PushButton *arg1 = 0 ;
69740   Dali::Toolkit::PushButton *result = 0 ;
69741
69742   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69743   if (!arg1) {
69744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
69745     return 0;
69746   }
69747   {
69748     try {
69749       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
69750     } catch (std::out_of_range& e) {
69751       {
69752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69753       };
69754     } catch (std::exception& e) {
69755       {
69756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69757       };
69758     } catch (Dali::DaliException e) {
69759       {
69760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69761       };
69762     } catch (...) {
69763       {
69764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69765       };
69766     }
69767   }
69768
69769   jresult = (void *)result;
69770   return jresult;
69771 }
69772
69773
69774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
69775   void * jresult ;
69776   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
69777   Dali::Toolkit::PushButton *arg2 = 0 ;
69778   Dali::Toolkit::PushButton *result = 0 ;
69779
69780   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69781   arg2 = (Dali::Toolkit::PushButton *)jarg2;
69782   if (!arg2) {
69783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
69784     return 0;
69785   }
69786   {
69787     try {
69788       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
69789     } catch (std::out_of_range& e) {
69790       {
69791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69792       };
69793     } catch (std::exception& e) {
69794       {
69795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69796       };
69797     } catch (Dali::DaliException e) {
69798       {
69799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69800       };
69801     } catch (...) {
69802       {
69803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69804       };
69805     }
69806   }
69807
69808   jresult = (void *)result;
69809   return jresult;
69810 }
69811
69812
69813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
69814   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
69815
69816   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69817   {
69818     try {
69819       delete arg1;
69820     } catch (std::out_of_range& e) {
69821       {
69822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69823       };
69824     } catch (std::exception& e) {
69825       {
69826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69827       };
69828     } catch (Dali::DaliException e) {
69829       {
69830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69831       };
69832     } catch (...) {
69833       {
69834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69835       };
69836     }
69837   }
69838
69839 }
69840
69841
69842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
69843   void * jresult ;
69844   Dali::Toolkit::PushButton result;
69845
69846   {
69847     try {
69848       result = Dali::Toolkit::PushButton::New();
69849     } catch (std::out_of_range& e) {
69850       {
69851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69852       };
69853     } catch (std::exception& e) {
69854       {
69855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69856       };
69857     } catch (Dali::DaliException e) {
69858       {
69859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69860       };
69861     } catch (...) {
69862       {
69863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69864       };
69865     }
69866   }
69867
69868   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
69869   return jresult;
69870 }
69871
69872
69873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
69874   void * jresult ;
69875   Dali::BaseHandle arg1 ;
69876   Dali::BaseHandle *argp1 ;
69877   Dali::Toolkit::PushButton result;
69878
69879   argp1 = (Dali::BaseHandle *)jarg1;
69880   if (!argp1) {
69881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69882     return 0;
69883   }
69884   arg1 = *argp1;
69885   {
69886     try {
69887       result = Dali::Toolkit::PushButton::DownCast(arg1);
69888     } catch (std::out_of_range& e) {
69889       {
69890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69891       };
69892     } catch (std::exception& e) {
69893       {
69894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69895       };
69896     } catch (Dali::DaliException e) {
69897       {
69898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69899       };
69900     } catch (...) {
69901       {
69902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69903       };
69904     }
69905   }
69906
69907   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
69908   return jresult;
69909 }
69910
69911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
69912   void * jresult ;
69913   Dali::Toolkit::RadioButton *result = 0 ;
69914
69915   {
69916     try {
69917       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
69918     } catch (std::out_of_range& e) {
69919       {
69920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69921       };
69922     } catch (std::exception& e) {
69923       {
69924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69925       };
69926     } catch (Dali::DaliException e) {
69927       {
69928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69929       };
69930     } catch (...) {
69931       {
69932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69933       };
69934     }
69935   }
69936
69937   jresult = (void *)result;
69938   return jresult;
69939 }
69940
69941
69942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
69943   void * jresult ;
69944   Dali::Toolkit::RadioButton *arg1 = 0 ;
69945   Dali::Toolkit::RadioButton *result = 0 ;
69946
69947   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
69948   if (!arg1) {
69949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
69950     return 0;
69951   }
69952   {
69953     try {
69954       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
69955     } catch (std::out_of_range& e) {
69956       {
69957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69958       };
69959     } catch (std::exception& e) {
69960       {
69961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69962       };
69963     } catch (Dali::DaliException e) {
69964       {
69965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69966       };
69967     } catch (...) {
69968       {
69969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69970       };
69971     }
69972   }
69973
69974   jresult = (void *)result;
69975   return jresult;
69976 }
69977
69978
69979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
69980   void * jresult ;
69981   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
69982   Dali::Toolkit::RadioButton *arg2 = 0 ;
69983   Dali::Toolkit::RadioButton *result = 0 ;
69984
69985   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
69986   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
69987   if (!arg2) {
69988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
69989     return 0;
69990   }
69991   {
69992     try {
69993       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
69994     } catch (std::out_of_range& e) {
69995       {
69996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69997       };
69998     } catch (std::exception& e) {
69999       {
70000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70001       };
70002     } catch (Dali::DaliException e) {
70003       {
70004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70005       };
70006     } catch (...) {
70007       {
70008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70009       };
70010     }
70011   }
70012
70013   jresult = (void *)result;
70014   return jresult;
70015 }
70016
70017
70018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
70019   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
70020
70021   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70022   {
70023     try {
70024       delete arg1;
70025     } catch (std::out_of_range& e) {
70026       {
70027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70028       };
70029     } catch (std::exception& e) {
70030       {
70031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70032       };
70033     } catch (Dali::DaliException e) {
70034       {
70035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70036       };
70037     } catch (...) {
70038       {
70039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70040       };
70041     }
70042   }
70043
70044 }
70045
70046
70047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
70048   void * jresult ;
70049   Dali::Toolkit::RadioButton result;
70050
70051   {
70052     try {
70053       result = Dali::Toolkit::RadioButton::New();
70054     } catch (std::out_of_range& e) {
70055       {
70056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70057       };
70058     } catch (std::exception& e) {
70059       {
70060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70061       };
70062     } catch (Dali::DaliException e) {
70063       {
70064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70065       };
70066     } catch (...) {
70067       {
70068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70069       };
70070     }
70071   }
70072
70073   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70074   return jresult;
70075 }
70076
70077
70078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
70079   void * jresult ;
70080   std::string *arg1 = 0 ;
70081   Dali::Toolkit::RadioButton result;
70082
70083   if (!jarg1) {
70084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70085     return 0;
70086   }
70087   std::string arg1_str(jarg1);
70088   arg1 = &arg1_str;
70089   {
70090     try {
70091       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
70092     } catch (std::out_of_range& e) {
70093       {
70094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70095       };
70096     } catch (std::exception& e) {
70097       {
70098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70099       };
70100     } catch (Dali::DaliException e) {
70101       {
70102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70103       };
70104     } catch (...) {
70105       {
70106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70107       };
70108     }
70109   }
70110
70111   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70112
70113   //argout typemap for const std::string&
70114
70115   return jresult;
70116 }
70117
70118
70119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
70120   void * jresult ;
70121   Dali::BaseHandle arg1 ;
70122   Dali::BaseHandle *argp1 ;
70123   Dali::Toolkit::RadioButton result;
70124
70125   argp1 = (Dali::BaseHandle *)jarg1;
70126   if (!argp1) {
70127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70128     return 0;
70129   }
70130   arg1 = *argp1;
70131   {
70132     try {
70133       result = Dali::Toolkit::RadioButton::DownCast(arg1);
70134     } catch (std::out_of_range& e) {
70135       {
70136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70137       };
70138     } catch (std::exception& e) {
70139       {
70140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70141       };
70142     } catch (Dali::DaliException e) {
70143       {
70144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70145       };
70146     } catch (...) {
70147       {
70148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70149       };
70150     }
70151   }
70152
70153   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70154   return jresult;
70155 }
70156
70157
70158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
70159   int jresult ;
70160   int result;
70161
70162   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
70163   jresult = (int)result;
70164   return jresult;
70165 }
70166
70167
70168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
70169   int jresult ;
70170   int result;
70171
70172   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
70173   jresult = (int)result;
70174   return jresult;
70175 }
70176
70177
70178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
70179   int jresult ;
70180   int result;
70181
70182   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
70183   jresult = (int)result;
70184   return jresult;
70185 }
70186
70187
70188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
70189   int jresult ;
70190   int result;
70191
70192   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
70193   jresult = (int)result;
70194   return jresult;
70195 }
70196
70197
70198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
70199   int jresult ;
70200   int result;
70201
70202   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
70203   jresult = (int)result;
70204   return jresult;
70205 }
70206
70207
70208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
70209   int jresult ;
70210   int result;
70211
70212   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
70213   jresult = (int)result;
70214   return jresult;
70215 }
70216
70217
70218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
70219   void * jresult ;
70220   Dali::Toolkit::FlexContainer::Property *result = 0 ;
70221
70222   {
70223     try {
70224       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
70225     } catch (std::out_of_range& e) {
70226       {
70227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70228       };
70229     } catch (std::exception& e) {
70230       {
70231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70232       };
70233     } catch (Dali::DaliException e) {
70234       {
70235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70236       };
70237     } catch (...) {
70238       {
70239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70240       };
70241     }
70242   }
70243
70244   jresult = (void *)result;
70245   return jresult;
70246 }
70247
70248
70249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
70250   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
70251
70252   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
70253   {
70254     try {
70255       delete arg1;
70256     } catch (std::out_of_range& e) {
70257       {
70258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70259       };
70260     } catch (std::exception& e) {
70261       {
70262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70263       };
70264     } catch (Dali::DaliException e) {
70265       {
70266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70267       };
70268     } catch (...) {
70269       {
70270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70271       };
70272     }
70273   }
70274
70275 }
70276
70277
70278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
70279   int jresult ;
70280   int result;
70281
70282   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
70283   jresult = (int)result;
70284   return jresult;
70285 }
70286
70287
70288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
70289   int jresult ;
70290   int result;
70291
70292   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
70293   jresult = (int)result;
70294   return jresult;
70295 }
70296
70297
70298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
70299   int jresult ;
70300   int result;
70301
70302   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
70303   jresult = (int)result;
70304   return jresult;
70305 }
70306
70307
70308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
70309   void * jresult ;
70310   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
70311
70312   {
70313     try {
70314       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
70315     } catch (std::out_of_range& e) {
70316       {
70317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70318       };
70319     } catch (std::exception& e) {
70320       {
70321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70322       };
70323     } catch (Dali::DaliException e) {
70324       {
70325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70326       };
70327     } catch (...) {
70328       {
70329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70330       };
70331     }
70332   }
70333
70334   jresult = (void *)result;
70335   return jresult;
70336 }
70337
70338
70339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
70340   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
70341
70342   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
70343   {
70344     try {
70345       delete arg1;
70346     } catch (std::out_of_range& e) {
70347       {
70348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70349       };
70350     } catch (std::exception& e) {
70351       {
70352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70353       };
70354     } catch (Dali::DaliException e) {
70355       {
70356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70357       };
70358     } catch (...) {
70359       {
70360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70361       };
70362     }
70363   }
70364
70365 }
70366
70367
70368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
70369   void * jresult ;
70370   Dali::Toolkit::FlexContainer *result = 0 ;
70371
70372   {
70373     try {
70374       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
70375     } catch (std::out_of_range& e) {
70376       {
70377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70378       };
70379     } catch (std::exception& e) {
70380       {
70381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70382       };
70383     } catch (Dali::DaliException e) {
70384       {
70385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70386       };
70387     } catch (...) {
70388       {
70389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70390       };
70391     }
70392   }
70393
70394   jresult = (void *)result;
70395   return jresult;
70396 }
70397
70398
70399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
70400   void * jresult ;
70401   Dali::Toolkit::FlexContainer *arg1 = 0 ;
70402   Dali::Toolkit::FlexContainer *result = 0 ;
70403
70404   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70405   if (!arg1) {
70406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
70407     return 0;
70408   }
70409   {
70410     try {
70411       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
70412     } catch (std::out_of_range& e) {
70413       {
70414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70415       };
70416     } catch (std::exception& e) {
70417       {
70418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70419       };
70420     } catch (Dali::DaliException e) {
70421       {
70422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70423       };
70424     } catch (...) {
70425       {
70426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70427       };
70428     }
70429   }
70430
70431   jresult = (void *)result;
70432   return jresult;
70433 }
70434
70435
70436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
70437   void * jresult ;
70438   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
70439   Dali::Toolkit::FlexContainer *arg2 = 0 ;
70440   Dali::Toolkit::FlexContainer *result = 0 ;
70441
70442   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70443   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
70444   if (!arg2) {
70445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
70446     return 0;
70447   }
70448   {
70449     try {
70450       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
70451     } catch (std::out_of_range& e) {
70452       {
70453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70454       };
70455     } catch (std::exception& e) {
70456       {
70457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70458       };
70459     } catch (Dali::DaliException e) {
70460       {
70461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70462       };
70463     } catch (...) {
70464       {
70465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70466       };
70467     }
70468   }
70469
70470   jresult = (void *)result;
70471   return jresult;
70472 }
70473
70474
70475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
70476   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
70477
70478   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70479   {
70480     try {
70481       delete arg1;
70482     } catch (std::out_of_range& e) {
70483       {
70484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70485       };
70486     } catch (std::exception& e) {
70487       {
70488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70489       };
70490     } catch (Dali::DaliException e) {
70491       {
70492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70493       };
70494     } catch (...) {
70495       {
70496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70497       };
70498     }
70499   }
70500
70501 }
70502
70503
70504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
70505   void * jresult ;
70506   Dali::Toolkit::FlexContainer result;
70507
70508   {
70509     try {
70510       result = Dali::Toolkit::FlexContainer::New();
70511     } catch (std::out_of_range& e) {
70512       {
70513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70514       };
70515     } catch (std::exception& e) {
70516       {
70517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70518       };
70519     } catch (Dali::DaliException e) {
70520       {
70521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70522       };
70523     } catch (...) {
70524       {
70525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70526       };
70527     }
70528   }
70529
70530   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
70531   return jresult;
70532 }
70533
70534
70535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
70536   void * jresult ;
70537   Dali::BaseHandle arg1 ;
70538   Dali::BaseHandle *argp1 ;
70539   Dali::Toolkit::FlexContainer result;
70540
70541   argp1 = (Dali::BaseHandle *)jarg1;
70542   if (!argp1) {
70543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70544     return 0;
70545   }
70546   arg1 = *argp1;
70547   {
70548     try {
70549       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
70550     } catch (std::out_of_range& e) {
70551       {
70552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70553       };
70554     } catch (std::exception& e) {
70555       {
70556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70557       };
70558     } catch (Dali::DaliException e) {
70559       {
70560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70561       };
70562     } catch (...) {
70563       {
70564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70565       };
70566     }
70567   }
70568
70569   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
70570   return jresult;
70571 }
70572
70573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
70574   int jresult ;
70575   int result;
70576
70577   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
70578   jresult = (int)result;
70579   return jresult;
70580 }
70581
70582
70583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
70584   int jresult ;
70585   int result;
70586
70587   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
70588   jresult = (int)result;
70589   return jresult;
70590 }
70591
70592
70593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
70594   int jresult ;
70595   int result;
70596
70597   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
70598   jresult = (int)result;
70599   return jresult;
70600 }
70601
70602
70603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
70604   void * jresult ;
70605   Dali::Toolkit::ImageView::Property *result = 0 ;
70606
70607   {
70608     try {
70609       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
70610     } catch (std::out_of_range& e) {
70611       {
70612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70613       };
70614     } catch (std::exception& e) {
70615       {
70616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70617       };
70618     } catch (Dali::DaliException e) {
70619       {
70620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70621       };
70622     } catch (...) {
70623       {
70624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70625       };
70626     }
70627   }
70628
70629   jresult = (void *)result;
70630   return jresult;
70631 }
70632
70633
70634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
70635   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
70636
70637   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
70638   {
70639     try {
70640       delete arg1;
70641     } catch (std::out_of_range& e) {
70642       {
70643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70644       };
70645     } catch (std::exception& e) {
70646       {
70647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70648       };
70649     } catch (Dali::DaliException e) {
70650       {
70651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70652       };
70653     } catch (...) {
70654       {
70655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70656       };
70657     }
70658   }
70659
70660 }
70661
70662
70663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
70664   void * jresult ;
70665   Dali::Toolkit::ImageView *result = 0 ;
70666
70667   {
70668     try {
70669       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
70670     } catch (std::out_of_range& e) {
70671       {
70672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70673       };
70674     } catch (std::exception& e) {
70675       {
70676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70677       };
70678     } catch (Dali::DaliException e) {
70679       {
70680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70681       };
70682     } catch (...) {
70683       {
70684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70685       };
70686     }
70687   }
70688
70689   jresult = (void *)result;
70690   return jresult;
70691 }
70692
70693
70694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
70695   void * jresult ;
70696   Dali::Toolkit::ImageView result;
70697
70698   {
70699     try {
70700       result = Dali::Toolkit::ImageView::New();
70701     } catch (std::out_of_range& e) {
70702       {
70703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70704       };
70705     } catch (std::exception& e) {
70706       {
70707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70708       };
70709     } catch (Dali::DaliException e) {
70710       {
70711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70712       };
70713     } catch (...) {
70714       {
70715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70716       };
70717     }
70718   }
70719
70720   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70721   return jresult;
70722 }
70723
70724
70725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
70726   void * jresult ;
70727   Dali::Image arg1 ;
70728   Dali::Image *argp1 ;
70729   Dali::Toolkit::ImageView result;
70730
70731   argp1 = (Dali::Image *)jarg1;
70732   if (!argp1) {
70733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70734     return 0;
70735   }
70736   arg1 = *argp1;
70737   {
70738     try {
70739       result = Dali::Toolkit::ImageView::New(arg1);
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   return jresult;
70761 }
70762
70763
70764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
70765   void * jresult ;
70766   std::string *arg1 = 0 ;
70767   Dali::Toolkit::ImageView result;
70768
70769   if (!jarg1) {
70770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70771     return 0;
70772   }
70773   std::string arg1_str(jarg1);
70774   arg1 = &arg1_str;
70775   {
70776     try {
70777       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
70778     } catch (std::out_of_range& e) {
70779       {
70780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70781       };
70782     } catch (std::exception& e) {
70783       {
70784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70785       };
70786     } catch (Dali::DaliException e) {
70787       {
70788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70789       };
70790     } catch (...) {
70791       {
70792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70793       };
70794     }
70795   }
70796
70797   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70798
70799   //argout typemap for const std::string&
70800
70801   return jresult;
70802 }
70803
70804
70805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
70806   void * jresult ;
70807   std::string *arg1 = 0 ;
70808   Dali::ImageDimensions arg2 ;
70809   Dali::ImageDimensions *argp2 ;
70810   Dali::Toolkit::ImageView result;
70811
70812   if (!jarg1) {
70813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70814     return 0;
70815   }
70816   std::string arg1_str(jarg1);
70817   arg1 = &arg1_str;
70818   argp2 = (Dali::ImageDimensions *)jarg2;
70819   if (!argp2) {
70820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
70821     return 0;
70822   }
70823   arg2 = *argp2;
70824   {
70825     try {
70826       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
70827     } catch (std::out_of_range& e) {
70828       {
70829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70830       };
70831     } catch (std::exception& e) {
70832       {
70833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70834       };
70835     } catch (Dali::DaliException e) {
70836       {
70837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70838       };
70839     } catch (...) {
70840       {
70841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70842       };
70843     }
70844   }
70845
70846   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70847
70848   //argout typemap for const std::string&
70849
70850   return jresult;
70851 }
70852
70853
70854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
70855   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70856
70857   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70858   {
70859     try {
70860       delete arg1;
70861     } catch (std::out_of_range& e) {
70862       {
70863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70864       };
70865     } catch (std::exception& e) {
70866       {
70867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70868       };
70869     } catch (Dali::DaliException e) {
70870       {
70871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70872       };
70873     } catch (...) {
70874       {
70875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70876       };
70877     }
70878   }
70879
70880 }
70881
70882
70883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
70884   void * jresult ;
70885   Dali::Toolkit::ImageView *arg1 = 0 ;
70886   Dali::Toolkit::ImageView *result = 0 ;
70887
70888   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70889   if (!arg1) {
70890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
70891     return 0;
70892   }
70893   {
70894     try {
70895       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
70896     } catch (std::out_of_range& e) {
70897       {
70898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70899       };
70900     } catch (std::exception& e) {
70901       {
70902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70903       };
70904     } catch (Dali::DaliException e) {
70905       {
70906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70907       };
70908     } catch (...) {
70909       {
70910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70911       };
70912     }
70913   }
70914
70915   jresult = (void *)result;
70916   return jresult;
70917 }
70918
70919
70920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
70921   void * jresult ;
70922   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70923   Dali::Toolkit::ImageView *arg2 = 0 ;
70924   Dali::Toolkit::ImageView *result = 0 ;
70925
70926   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70927   arg2 = (Dali::Toolkit::ImageView *)jarg2;
70928   if (!arg2) {
70929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
70930     return 0;
70931   }
70932   {
70933     try {
70934       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
70935     } catch (std::out_of_range& e) {
70936       {
70937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70938       };
70939     } catch (std::exception& e) {
70940       {
70941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70942       };
70943     } catch (Dali::DaliException e) {
70944       {
70945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70946       };
70947     } catch (...) {
70948       {
70949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70950       };
70951     }
70952   }
70953
70954   jresult = (void *)result;
70955   return jresult;
70956 }
70957
70958
70959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
70960   void * jresult ;
70961   Dali::BaseHandle arg1 ;
70962   Dali::BaseHandle *argp1 ;
70963   Dali::Toolkit::ImageView result;
70964
70965   argp1 = (Dali::BaseHandle *)jarg1;
70966   if (!argp1) {
70967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70968     return 0;
70969   }
70970   arg1 = *argp1;
70971   {
70972     try {
70973       result = Dali::Toolkit::ImageView::DownCast(arg1);
70974     } catch (std::out_of_range& e) {
70975       {
70976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70977       };
70978     } catch (std::exception& e) {
70979       {
70980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70981       };
70982     } catch (Dali::DaliException e) {
70983       {
70984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70985       };
70986     } catch (...) {
70987       {
70988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70989       };
70990     }
70991   }
70992
70993   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70994   return jresult;
70995 }
70996
70997
70998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
70999   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71000   Dali::Image arg2 ;
71001   Dali::Image *argp2 ;
71002
71003   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71004   argp2 = (Dali::Image *)jarg2;
71005   if (!argp2) {
71006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71007     return ;
71008   }
71009   arg2 = *argp2;
71010   {
71011     try {
71012       (arg1)->SetImage(arg2);
71013     } catch (std::out_of_range& e) {
71014       {
71015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71016       };
71017     } catch (std::exception& e) {
71018       {
71019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71020       };
71021     } catch (Dali::DaliException e) {
71022       {
71023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71024       };
71025     } catch (...) {
71026       {
71027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71028       };
71029     }
71030   }
71031
71032 }
71033
71034
71035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
71036   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71037   std::string *arg2 = 0 ;
71038
71039   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71040   if (!jarg2) {
71041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71042     return ;
71043   }
71044   std::string arg2_str(jarg2);
71045   arg2 = &arg2_str;
71046   {
71047     try {
71048       (arg1)->SetImage((std::string const &)*arg2);
71049     } catch (std::out_of_range& e) {
71050       {
71051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71052       };
71053     } catch (std::exception& e) {
71054       {
71055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71056       };
71057     } catch (Dali::DaliException e) {
71058       {
71059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71060       };
71061     } catch (...) {
71062       {
71063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71064       };
71065     }
71066   }
71067
71068
71069   //argout typemap for const std::string&
71070
71071 }
71072
71073
71074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
71075   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71076   std::string *arg2 = 0 ;
71077   Dali::ImageDimensions arg3 ;
71078   Dali::ImageDimensions *argp3 ;
71079
71080   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71081   if (!jarg2) {
71082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71083     return ;
71084   }
71085   std::string arg2_str(jarg2);
71086   arg2 = &arg2_str;
71087   argp3 = (Dali::ImageDimensions *)jarg3;
71088   if (!argp3) {
71089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71090     return ;
71091   }
71092   arg3 = *argp3;
71093   {
71094     try {
71095       (arg1)->SetImage((std::string const &)*arg2,arg3);
71096     } catch (std::out_of_range& e) {
71097       {
71098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71099       };
71100     } catch (std::exception& e) {
71101       {
71102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71103       };
71104     } catch (Dali::DaliException e) {
71105       {
71106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71107       };
71108     } catch (...) {
71109       {
71110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71111       };
71112     }
71113   }
71114
71115
71116   //argout typemap for const std::string&
71117
71118 }
71119
71120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
71121   void * jresult ;
71122   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71123   Dali::Image result;
71124
71125   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71126   {
71127     try {
71128       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
71129     } catch (std::out_of_range& e) {
71130       {
71131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71132       };
71133     } catch (std::exception& e) {
71134       {
71135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71136       };
71137     } catch (Dali::DaliException e) {
71138       {
71139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71140       };
71141     } catch (...) {
71142       {
71143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71144       };
71145     }
71146   }
71147
71148   jresult = new Dali::Image((const Dali::Image &)result);
71149   return jresult;
71150 }
71151
71152
71153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
71154   int jresult ;
71155   int result;
71156
71157   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
71158   jresult = (int)result;
71159   return jresult;
71160 }
71161
71162
71163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
71164   int jresult ;
71165   int result;
71166
71167   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
71168   jresult = (int)result;
71169   return jresult;
71170 }
71171
71172
71173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
71174   int jresult ;
71175   int result;
71176
71177   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
71178   jresult = (int)result;
71179   return jresult;
71180 }
71181
71182
71183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
71184   int jresult ;
71185   int result;
71186
71187   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
71188   jresult = (int)result;
71189   return jresult;
71190 }
71191
71192
71193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
71194   int jresult ;
71195   int result;
71196
71197   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
71198   jresult = (int)result;
71199   return jresult;
71200 }
71201
71202
71203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
71204   int jresult ;
71205   int result;
71206
71207   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
71208   jresult = (int)result;
71209   return jresult;
71210 }
71211
71212
71213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
71214   int jresult ;
71215   int result;
71216
71217   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
71218   jresult = (int)result;
71219   return jresult;
71220 }
71221
71222
71223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
71224   int jresult ;
71225   int result;
71226
71227   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
71228   jresult = (int)result;
71229   return jresult;
71230 }
71231
71232
71233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
71234   void * jresult ;
71235   Dali::Toolkit::Model3dView::Property *result = 0 ;
71236
71237   {
71238     try {
71239       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
71240     } catch (std::out_of_range& e) {
71241       {
71242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71243       };
71244     } catch (std::exception& e) {
71245       {
71246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71247       };
71248     } catch (Dali::DaliException e) {
71249       {
71250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71251       };
71252     } catch (...) {
71253       {
71254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71255       };
71256     }
71257   }
71258
71259   jresult = (void *)result;
71260   return jresult;
71261 }
71262
71263
71264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
71265   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
71266
71267   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
71268   {
71269     try {
71270       delete arg1;
71271     } catch (std::out_of_range& e) {
71272       {
71273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71274       };
71275     } catch (std::exception& e) {
71276       {
71277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71278       };
71279     } catch (Dali::DaliException e) {
71280       {
71281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71282       };
71283     } catch (...) {
71284       {
71285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71286       };
71287     }
71288   }
71289
71290 }
71291
71292
71293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
71294   void * jresult ;
71295   Dali::Toolkit::Model3dView result;
71296
71297   {
71298     try {
71299       result = Dali::Toolkit::Model3dView::New();
71300     } catch (std::out_of_range& e) {
71301       {
71302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71303       };
71304     } catch (std::exception& e) {
71305       {
71306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71307       };
71308     } catch (Dali::DaliException e) {
71309       {
71310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71311       };
71312     } catch (...) {
71313       {
71314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71315       };
71316     }
71317   }
71318
71319   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71320   return jresult;
71321 }
71322
71323
71324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
71325   void * jresult ;
71326   std::string *arg1 = 0 ;
71327   std::string *arg2 = 0 ;
71328   std::string *arg3 = 0 ;
71329   Dali::Toolkit::Model3dView result;
71330
71331   if (!jarg1) {
71332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71333     return 0;
71334   }
71335   std::string arg1_str(jarg1);
71336   arg1 = &arg1_str;
71337   if (!jarg2) {
71338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71339     return 0;
71340   }
71341   std::string arg2_str(jarg2);
71342   arg2 = &arg2_str;
71343   if (!jarg3) {
71344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71345     return 0;
71346   }
71347   std::string arg3_str(jarg3);
71348   arg3 = &arg3_str;
71349   {
71350     try {
71351       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
71352     } catch (std::out_of_range& e) {
71353       {
71354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71355       };
71356     } catch (std::exception& e) {
71357       {
71358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71359       };
71360     } catch (Dali::DaliException e) {
71361       {
71362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71363       };
71364     } catch (...) {
71365       {
71366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71367       };
71368     }
71369   }
71370
71371   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71372
71373   //argout typemap for const std::string&
71374
71375
71376   //argout typemap for const std::string&
71377
71378
71379   //argout typemap for const std::string&
71380
71381   return jresult;
71382 }
71383
71384
71385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
71386   void * jresult ;
71387   Dali::Toolkit::Model3dView *result = 0 ;
71388
71389   {
71390     try {
71391       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
71392     } catch (std::out_of_range& e) {
71393       {
71394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71395       };
71396     } catch (std::exception& e) {
71397       {
71398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71399       };
71400     } catch (Dali::DaliException e) {
71401       {
71402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71403       };
71404     } catch (...) {
71405       {
71406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71407       };
71408     }
71409   }
71410
71411   jresult = (void *)result;
71412   return jresult;
71413 }
71414
71415
71416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
71417   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
71418
71419   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71420   {
71421     try {
71422       delete arg1;
71423     } catch (std::out_of_range& e) {
71424       {
71425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71426       };
71427     } catch (std::exception& e) {
71428       {
71429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71430       };
71431     } catch (Dali::DaliException e) {
71432       {
71433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71434       };
71435     } catch (...) {
71436       {
71437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71438       };
71439     }
71440   }
71441
71442 }
71443
71444
71445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
71446   void * jresult ;
71447   Dali::Toolkit::Model3dView *arg1 = 0 ;
71448   Dali::Toolkit::Model3dView *result = 0 ;
71449
71450   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71451   if (!arg1) {
71452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
71453     return 0;
71454   }
71455   {
71456     try {
71457       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
71458     } catch (std::out_of_range& e) {
71459       {
71460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71461       };
71462     } catch (std::exception& e) {
71463       {
71464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71465       };
71466     } catch (Dali::DaliException e) {
71467       {
71468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71469       };
71470     } catch (...) {
71471       {
71472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71473       };
71474     }
71475   }
71476
71477   jresult = (void *)result;
71478   return jresult;
71479 }
71480
71481
71482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
71483   void * jresult ;
71484   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
71485   Dali::Toolkit::Model3dView *arg2 = 0 ;
71486   Dali::Toolkit::Model3dView *result = 0 ;
71487
71488   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71489   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
71490   if (!arg2) {
71491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
71492     return 0;
71493   }
71494   {
71495     try {
71496       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
71497     } catch (std::out_of_range& e) {
71498       {
71499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71500       };
71501     } catch (std::exception& e) {
71502       {
71503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71504       };
71505     } catch (Dali::DaliException e) {
71506       {
71507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71508       };
71509     } catch (...) {
71510       {
71511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71512       };
71513     }
71514   }
71515
71516   jresult = (void *)result;
71517   return jresult;
71518 }
71519
71520
71521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
71522   void * jresult ;
71523   Dali::BaseHandle arg1 ;
71524   Dali::BaseHandle *argp1 ;
71525   Dali::Toolkit::Model3dView result;
71526
71527   argp1 = (Dali::BaseHandle *)jarg1;
71528   if (!argp1) {
71529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71530     return 0;
71531   }
71532   arg1 = *argp1;
71533   {
71534     try {
71535       result = Dali::Toolkit::Model3dView::DownCast(arg1);
71536     } catch (std::out_of_range& e) {
71537       {
71538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71539       };
71540     } catch (std::exception& e) {
71541       {
71542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71543       };
71544     } catch (Dali::DaliException e) {
71545       {
71546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71547       };
71548     } catch (...) {
71549       {
71550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71551       };
71552     }
71553   }
71554
71555   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71556   return jresult;
71557 }
71558
71559
71560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
71561   int jresult ;
71562   int result;
71563
71564   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
71565   jresult = (int)result;
71566   return jresult;
71567 }
71568
71569
71570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
71571   int jresult ;
71572   int result;
71573
71574   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
71575   jresult = (int)result;
71576   return jresult;
71577 }
71578
71579
71580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
71581   int jresult ;
71582   int result;
71583
71584   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
71585   jresult = (int)result;
71586   return jresult;
71587 }
71588
71589
71590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
71591   int jresult ;
71592   int result;
71593
71594   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
71595   jresult = (int)result;
71596   return jresult;
71597 }
71598
71599
71600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
71601   int jresult ;
71602   int result;
71603
71604   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
71605   jresult = (int)result;
71606   return jresult;
71607 }
71608
71609
71610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
71611   int jresult ;
71612   int result;
71613
71614   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
71615   jresult = (int)result;
71616   return jresult;
71617 }
71618
71619
71620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
71621   int jresult ;
71622   int result;
71623
71624   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
71625   jresult = (int)result;
71626   return jresult;
71627 }
71628
71629
71630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
71631   int jresult ;
71632   int result;
71633
71634   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
71635   jresult = (int)result;
71636   return jresult;
71637 }
71638
71639
71640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
71641   int jresult ;
71642   int result;
71643
71644   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
71645   jresult = (int)result;
71646   return jresult;
71647 }
71648
71649
71650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
71651   void * jresult ;
71652   Dali::Toolkit::ScrollBar::Property *result = 0 ;
71653
71654   {
71655     try {
71656       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
71657     } catch (std::out_of_range& e) {
71658       {
71659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71660       };
71661     } catch (std::exception& e) {
71662       {
71663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71664       };
71665     } catch (Dali::DaliException e) {
71666       {
71667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71668       };
71669     } catch (...) {
71670       {
71671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71672       };
71673     }
71674   }
71675
71676   jresult = (void *)result;
71677   return jresult;
71678 }
71679
71680
71681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
71682   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
71683
71684   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
71685   {
71686     try {
71687       delete arg1;
71688     } catch (std::out_of_range& e) {
71689       {
71690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71691       };
71692     } catch (std::exception& e) {
71693       {
71694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71695       };
71696     } catch (Dali::DaliException e) {
71697       {
71698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71699       };
71700     } catch (...) {
71701       {
71702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71703       };
71704     }
71705   }
71706
71707 }
71708
71709
71710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
71711   void * jresult ;
71712   Dali::Toolkit::ScrollBar *result = 0 ;
71713
71714   {
71715     try {
71716       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
71717     } catch (std::out_of_range& e) {
71718       {
71719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71720       };
71721     } catch (std::exception& e) {
71722       {
71723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71724       };
71725     } catch (Dali::DaliException e) {
71726       {
71727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71728       };
71729     } catch (...) {
71730       {
71731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71732       };
71733     }
71734   }
71735
71736   jresult = (void *)result;
71737   return jresult;
71738 }
71739
71740
71741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
71742   void * jresult ;
71743   Dali::Toolkit::ScrollBar *arg1 = 0 ;
71744   Dali::Toolkit::ScrollBar *result = 0 ;
71745
71746   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71747   if (!arg1) {
71748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
71749     return 0;
71750   }
71751   {
71752     try {
71753       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
71754     } catch (std::out_of_range& e) {
71755       {
71756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71757       };
71758     } catch (std::exception& e) {
71759       {
71760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71761       };
71762     } catch (Dali::DaliException e) {
71763       {
71764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71765       };
71766     } catch (...) {
71767       {
71768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71769       };
71770     }
71771   }
71772
71773   jresult = (void *)result;
71774   return jresult;
71775 }
71776
71777
71778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
71779   void * jresult ;
71780   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71781   Dali::Toolkit::ScrollBar *arg2 = 0 ;
71782   Dali::Toolkit::ScrollBar *result = 0 ;
71783
71784   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71785   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
71786   if (!arg2) {
71787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
71788     return 0;
71789   }
71790   {
71791     try {
71792       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
71793     } catch (std::out_of_range& e) {
71794       {
71795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71796       };
71797     } catch (std::exception& e) {
71798       {
71799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71800       };
71801     } catch (Dali::DaliException e) {
71802       {
71803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71804       };
71805     } catch (...) {
71806       {
71807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71808       };
71809     }
71810   }
71811
71812   jresult = (void *)result;
71813   return jresult;
71814 }
71815
71816
71817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
71818   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71819
71820   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71821   {
71822     try {
71823       delete arg1;
71824     } catch (std::out_of_range& e) {
71825       {
71826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71827       };
71828     } catch (std::exception& e) {
71829       {
71830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71831       };
71832     } catch (Dali::DaliException e) {
71833       {
71834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71835       };
71836     } catch (...) {
71837       {
71838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71839       };
71840     }
71841   }
71842
71843 }
71844
71845
71846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
71847   void * jresult ;
71848   Dali::Toolkit::ScrollBar::Direction arg1 ;
71849   Dali::Toolkit::ScrollBar result;
71850
71851   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
71852   {
71853     try {
71854       result = Dali::Toolkit::ScrollBar::New(arg1);
71855     } catch (std::out_of_range& e) {
71856       {
71857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71858       };
71859     } catch (std::exception& e) {
71860       {
71861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71862       };
71863     } catch (Dali::DaliException e) {
71864       {
71865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71866       };
71867     } catch (...) {
71868       {
71869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71870       };
71871     }
71872   }
71873
71874   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71875   return jresult;
71876 }
71877
71878
71879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
71880   void * jresult ;
71881   Dali::Toolkit::ScrollBar result;
71882
71883   {
71884     try {
71885       result = Dali::Toolkit::ScrollBar::New();
71886     } catch (std::out_of_range& e) {
71887       {
71888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71889       };
71890     } catch (std::exception& e) {
71891       {
71892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71893       };
71894     } catch (Dali::DaliException e) {
71895       {
71896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71897       };
71898     } catch (...) {
71899       {
71900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71901       };
71902     }
71903   }
71904
71905   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71906   return jresult;
71907 }
71908
71909
71910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
71911   void * jresult ;
71912   Dali::BaseHandle arg1 ;
71913   Dali::BaseHandle *argp1 ;
71914   Dali::Toolkit::ScrollBar result;
71915
71916   argp1 = (Dali::BaseHandle *)jarg1;
71917   if (!argp1) {
71918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71919     return 0;
71920   }
71921   arg1 = *argp1;
71922   {
71923     try {
71924       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
71925     } catch (std::out_of_range& e) {
71926       {
71927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71928       };
71929     } catch (std::exception& e) {
71930       {
71931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71932       };
71933     } catch (Dali::DaliException e) {
71934       {
71935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71936       };
71937     } catch (...) {
71938       {
71939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71940       };
71941     }
71942   }
71943
71944   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71945   return jresult;
71946 }
71947
71948
71949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
71950   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71951   Dali::Handle arg2 ;
71952   Dali::Property::Index arg3 ;
71953   Dali::Property::Index arg4 ;
71954   Dali::Property::Index arg5 ;
71955   Dali::Property::Index arg6 ;
71956   Dali::Handle *argp2 ;
71957
71958   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71959   argp2 = (Dali::Handle *)jarg2;
71960   if (!argp2) {
71961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
71962     return ;
71963   }
71964   arg2 = *argp2;
71965   arg3 = (Dali::Property::Index)jarg3;
71966   arg4 = (Dali::Property::Index)jarg4;
71967   arg5 = (Dali::Property::Index)jarg5;
71968   arg6 = (Dali::Property::Index)jarg6;
71969   {
71970     try {
71971       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
71972     } catch (std::out_of_range& e) {
71973       {
71974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71975       };
71976     } catch (std::exception& e) {
71977       {
71978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71979       };
71980     } catch (Dali::DaliException e) {
71981       {
71982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71983       };
71984     } catch (...) {
71985       {
71986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71987       };
71988     }
71989   }
71990
71991 }
71992
71993
71994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
71995   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71996   Dali::Actor arg2 ;
71997   Dali::Actor *argp2 ;
71998
71999   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72000   argp2 = (Dali::Actor *)jarg2;
72001   if (!argp2) {
72002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72003     return ;
72004   }
72005   arg2 = *argp2;
72006   {
72007     try {
72008       (arg1)->SetScrollIndicator(arg2);
72009     } catch (std::out_of_range& e) {
72010       {
72011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72012       };
72013     } catch (std::exception& e) {
72014       {
72015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72016       };
72017     } catch (Dali::DaliException e) {
72018       {
72019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72020       };
72021     } catch (...) {
72022       {
72023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72024       };
72025     }
72026   }
72027
72028 }
72029
72030
72031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
72032   void * jresult ;
72033   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72034   Dali::Actor result;
72035
72036   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72037   {
72038     try {
72039       result = (arg1)->GetScrollIndicator();
72040     } catch (std::out_of_range& e) {
72041       {
72042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72043       };
72044     } catch (std::exception& e) {
72045       {
72046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72047       };
72048     } catch (Dali::DaliException e) {
72049       {
72050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72051       };
72052     } catch (...) {
72053       {
72054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72055       };
72056     }
72057   }
72058
72059   jresult = new Dali::Actor((const Dali::Actor &)result);
72060   return jresult;
72061 }
72062
72063
72064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
72065   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72066   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
72067
72068   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72069   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
72070   if (!arg2) {
72071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
72072     return ;
72073   }
72074   {
72075     try {
72076       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
72077     } catch (std::out_of_range& e) {
72078       {
72079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72080       };
72081     } catch (std::exception& e) {
72082       {
72083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72084       };
72085     } catch (Dali::DaliException e) {
72086       {
72087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72088       };
72089     } catch (...) {
72090       {
72091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72092       };
72093     }
72094   }
72095
72096 }
72097
72098
72099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
72100   void * jresult ;
72101   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72102
72103   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72104   {
72105     try {
72106       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()));
72107     } catch (std::out_of_range& e) {
72108       {
72109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72110       };
72111     } catch (std::exception& e) {
72112       {
72113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72114       };
72115     } catch (...) {
72116       {
72117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72118       };
72119     }
72120   }
72121   return jresult;
72122 }
72123
72124
72125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
72126   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72127   Dali::Toolkit::ScrollBar::Direction arg2 ;
72128
72129   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72130   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
72131   {
72132     try {
72133       (arg1)->SetScrollDirection(arg2);
72134     } catch (std::out_of_range& e) {
72135       {
72136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72137       };
72138     } catch (std::exception& e) {
72139       {
72140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72141       };
72142     } catch (Dali::DaliException e) {
72143       {
72144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72145       };
72146     } catch (...) {
72147       {
72148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72149       };
72150     }
72151   }
72152
72153 }
72154
72155
72156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
72157   int jresult ;
72158   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72159   Dali::Toolkit::ScrollBar::Direction result;
72160
72161   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72162   {
72163     try {
72164       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
72165     } catch (std::out_of_range& e) {
72166       {
72167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72168       };
72169     } catch (std::exception& e) {
72170       {
72171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72172       };
72173     } catch (Dali::DaliException e) {
72174       {
72175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72176       };
72177     } catch (...) {
72178       {
72179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72180       };
72181     }
72182   }
72183
72184   jresult = (int)result;
72185   return jresult;
72186 }
72187
72188
72189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
72190   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72191   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
72192
72193   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72194   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
72195   {
72196     try {
72197       (arg1)->SetIndicatorHeightPolicy(arg2);
72198     } catch (std::out_of_range& e) {
72199       {
72200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72201       };
72202     } catch (std::exception& e) {
72203       {
72204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72205       };
72206     } catch (Dali::DaliException e) {
72207       {
72208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72209       };
72210     } catch (...) {
72211       {
72212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72213       };
72214     }
72215   }
72216
72217 }
72218
72219
72220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
72221   int jresult ;
72222   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72223   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
72224
72225   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72226   {
72227     try {
72228       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
72229     } catch (std::out_of_range& e) {
72230       {
72231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72232       };
72233     } catch (std::exception& e) {
72234       {
72235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72236       };
72237     } catch (Dali::DaliException e) {
72238       {
72239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72240       };
72241     } catch (...) {
72242       {
72243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72244       };
72245     }
72246   }
72247
72248   jresult = (int)result;
72249   return jresult;
72250 }
72251
72252
72253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
72254   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72255   float arg2 ;
72256
72257   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72258   arg2 = (float)jarg2;
72259   {
72260     try {
72261       (arg1)->SetIndicatorFixedHeight(arg2);
72262     } catch (std::out_of_range& e) {
72263       {
72264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72265       };
72266     } catch (std::exception& e) {
72267       {
72268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72269       };
72270     } catch (Dali::DaliException e) {
72271       {
72272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72273       };
72274     } catch (...) {
72275       {
72276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72277       };
72278     }
72279   }
72280
72281 }
72282
72283
72284 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
72285   float jresult ;
72286   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72287   float result;
72288
72289   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72290   {
72291     try {
72292       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
72293     } catch (std::out_of_range& e) {
72294       {
72295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72296       };
72297     } catch (std::exception& e) {
72298       {
72299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72300       };
72301     } catch (Dali::DaliException e) {
72302       {
72303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72304       };
72305     } catch (...) {
72306       {
72307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72308       };
72309     }
72310   }
72311
72312   jresult = result;
72313   return jresult;
72314 }
72315
72316
72317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
72318   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72319   float arg2 ;
72320
72321   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72322   arg2 = (float)jarg2;
72323   {
72324     try {
72325       (arg1)->SetIndicatorShowDuration(arg2);
72326     } catch (std::out_of_range& e) {
72327       {
72328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72329       };
72330     } catch (std::exception& e) {
72331       {
72332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72333       };
72334     } catch (Dali::DaliException e) {
72335       {
72336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72337       };
72338     } catch (...) {
72339       {
72340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72341       };
72342     }
72343   }
72344
72345 }
72346
72347
72348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
72349   float jresult ;
72350   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72351   float result;
72352
72353   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72354   {
72355     try {
72356       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
72357     } catch (std::out_of_range& e) {
72358       {
72359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72360       };
72361     } catch (std::exception& e) {
72362       {
72363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72364       };
72365     } catch (Dali::DaliException e) {
72366       {
72367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72368       };
72369     } catch (...) {
72370       {
72371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72372       };
72373     }
72374   }
72375
72376   jresult = result;
72377   return jresult;
72378 }
72379
72380
72381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
72382   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72383   float arg2 ;
72384
72385   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72386   arg2 = (float)jarg2;
72387   {
72388     try {
72389       (arg1)->SetIndicatorHideDuration(arg2);
72390     } catch (std::out_of_range& e) {
72391       {
72392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72393       };
72394     } catch (std::exception& e) {
72395       {
72396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72397       };
72398     } catch (Dali::DaliException e) {
72399       {
72400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72401       };
72402     } catch (...) {
72403       {
72404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72405       };
72406     }
72407   }
72408
72409 }
72410
72411
72412 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
72413   float jresult ;
72414   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72415   float result;
72416
72417   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72418   {
72419     try {
72420       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
72421     } catch (std::out_of_range& e) {
72422       {
72423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72424       };
72425     } catch (std::exception& e) {
72426       {
72427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72428       };
72429     } catch (Dali::DaliException e) {
72430       {
72431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72432       };
72433     } catch (...) {
72434       {
72435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72436       };
72437     }
72438   }
72439
72440   jresult = result;
72441   return jresult;
72442 }
72443
72444
72445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
72446   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72447
72448   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72449   {
72450     try {
72451       (arg1)->ShowIndicator();
72452     } catch (std::out_of_range& e) {
72453       {
72454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72455       };
72456     } catch (std::exception& e) {
72457       {
72458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72459       };
72460     } catch (Dali::DaliException e) {
72461       {
72462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72463       };
72464     } catch (...) {
72465       {
72466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72467       };
72468     }
72469   }
72470
72471 }
72472
72473
72474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
72475   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72476
72477   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72478   {
72479     try {
72480       (arg1)->HideIndicator();
72481     } catch (std::out_of_range& e) {
72482       {
72483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72484       };
72485     } catch (std::exception& e) {
72486       {
72487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72488       };
72489     } catch (Dali::DaliException e) {
72490       {
72491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72492       };
72493     } catch (...) {
72494       {
72495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72496       };
72497     }
72498   }
72499
72500 }
72501
72502
72503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
72504   void * jresult ;
72505   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72506   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
72507
72508   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72509   {
72510     try {
72511       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
72512     } catch (std::out_of_range& e) {
72513       {
72514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72515       };
72516     } catch (std::exception& e) {
72517       {
72518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72519       };
72520     } catch (Dali::DaliException e) {
72521       {
72522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72523       };
72524     } catch (...) {
72525       {
72526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72527       };
72528     }
72529   }
72530
72531   jresult = (void *)result;
72532   return jresult;
72533 }
72534
72535
72536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
72537   void * jresult ;
72538   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72539   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
72540
72541   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72542   {
72543     try {
72544       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
72545     } catch (std::out_of_range& e) {
72546       {
72547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72548       };
72549     } catch (std::exception& e) {
72550       {
72551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72552       };
72553     } catch (Dali::DaliException e) {
72554       {
72555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72556       };
72557     } catch (...) {
72558       {
72559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72560       };
72561     }
72562   }
72563
72564   jresult = (void *)result;
72565   return jresult;
72566 }
72567
72568
72569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
72570   int jresult ;
72571   int result;
72572
72573   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
72574   jresult = (int)result;
72575   return jresult;
72576 }
72577
72578
72579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
72580   int jresult ;
72581   int result;
72582
72583   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
72584   jresult = (int)result;
72585   return jresult;
72586 }
72587
72588
72589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
72590   int jresult ;
72591   int result;
72592
72593   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
72594   jresult = (int)result;
72595   return jresult;
72596 }
72597
72598
72599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
72600   int jresult ;
72601   int result;
72602
72603   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
72604   jresult = (int)result;
72605   return jresult;
72606 }
72607
72608
72609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
72610   int jresult ;
72611   int result;
72612
72613   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
72614   jresult = (int)result;
72615   return jresult;
72616 }
72617
72618
72619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
72620   int jresult ;
72621   int result;
72622
72623   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
72624   jresult = (int)result;
72625   return jresult;
72626 }
72627
72628
72629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
72630   int jresult ;
72631   int result;
72632
72633   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
72634   jresult = (int)result;
72635   return jresult;
72636 }
72637
72638
72639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
72640   int jresult ;
72641   int result;
72642
72643   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
72644   jresult = (int)result;
72645   return jresult;
72646 }
72647
72648
72649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
72650   int jresult ;
72651   int result;
72652
72653   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
72654   jresult = (int)result;
72655   return jresult;
72656 }
72657
72658
72659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
72660   int jresult ;
72661   int result;
72662
72663   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
72664   jresult = (int)result;
72665   return jresult;
72666 }
72667
72668
72669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
72670   int jresult ;
72671   int result;
72672
72673   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
72674   jresult = (int)result;
72675   return jresult;
72676 }
72677
72678
72679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
72680   int jresult ;
72681   int result;
72682
72683   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
72684   jresult = (int)result;
72685   return jresult;
72686 }
72687
72688
72689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
72690   int jresult ;
72691   int result;
72692
72693   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
72694   jresult = (int)result;
72695   return jresult;
72696 }
72697
72698
72699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
72700   int jresult ;
72701   int result;
72702
72703   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
72704   jresult = (int)result;
72705   return jresult;
72706 }
72707
72708
72709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
72710   void * jresult ;
72711   Dali::Toolkit::Scrollable::Property *result = 0 ;
72712
72713   {
72714     try {
72715       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
72716     } catch (std::out_of_range& e) {
72717       {
72718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72719       };
72720     } catch (std::exception& e) {
72721       {
72722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72723       };
72724     } catch (Dali::DaliException e) {
72725       {
72726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72727       };
72728     } catch (...) {
72729       {
72730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72731       };
72732     }
72733   }
72734
72735   jresult = (void *)result;
72736   return jresult;
72737 }
72738
72739
72740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
72741   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
72742
72743   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
72744   {
72745     try {
72746       delete arg1;
72747     } catch (std::out_of_range& e) {
72748       {
72749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72750       };
72751     } catch (std::exception& e) {
72752       {
72753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72754       };
72755     } catch (Dali::DaliException e) {
72756       {
72757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72758       };
72759     } catch (...) {
72760       {
72761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72762       };
72763     }
72764   }
72765
72766 }
72767
72768
72769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
72770   void * jresult ;
72771   Dali::Toolkit::Scrollable *result = 0 ;
72772
72773   {
72774     try {
72775       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
72776     } catch (std::out_of_range& e) {
72777       {
72778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72779       };
72780     } catch (std::exception& e) {
72781       {
72782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72783       };
72784     } catch (Dali::DaliException e) {
72785       {
72786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72787       };
72788     } catch (...) {
72789       {
72790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72791       };
72792     }
72793   }
72794
72795   jresult = (void *)result;
72796   return jresult;
72797 }
72798
72799
72800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
72801   void * jresult ;
72802   Dali::Toolkit::Scrollable *arg1 = 0 ;
72803   Dali::Toolkit::Scrollable *result = 0 ;
72804
72805   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72806   if (!arg1) {
72807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
72808     return 0;
72809   }
72810   {
72811     try {
72812       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
72813     } catch (std::out_of_range& e) {
72814       {
72815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72816       };
72817     } catch (std::exception& e) {
72818       {
72819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72820       };
72821     } catch (Dali::DaliException e) {
72822       {
72823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72824       };
72825     } catch (...) {
72826       {
72827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72828       };
72829     }
72830   }
72831
72832   jresult = (void *)result;
72833   return jresult;
72834 }
72835
72836
72837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
72838   void * jresult ;
72839   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72840   Dali::Toolkit::Scrollable *arg2 = 0 ;
72841   Dali::Toolkit::Scrollable *result = 0 ;
72842
72843   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72844   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
72845   if (!arg2) {
72846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
72847     return 0;
72848   }
72849   {
72850     try {
72851       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
72852     } catch (std::out_of_range& e) {
72853       {
72854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72855       };
72856     } catch (std::exception& e) {
72857       {
72858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72859       };
72860     } catch (Dali::DaliException e) {
72861       {
72862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72863       };
72864     } catch (...) {
72865       {
72866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72867       };
72868     }
72869   }
72870
72871   jresult = (void *)result;
72872   return jresult;
72873 }
72874
72875
72876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
72877   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72878
72879   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72880   {
72881     try {
72882       delete arg1;
72883     } catch (std::out_of_range& e) {
72884       {
72885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72886       };
72887     } catch (std::exception& e) {
72888       {
72889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72890       };
72891     } catch (Dali::DaliException e) {
72892       {
72893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72894       };
72895     } catch (...) {
72896       {
72897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72898       };
72899     }
72900   }
72901
72902 }
72903
72904
72905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
72906   void * jresult ;
72907   Dali::BaseHandle arg1 ;
72908   Dali::BaseHandle *argp1 ;
72909   Dali::Toolkit::Scrollable result;
72910
72911   argp1 = (Dali::BaseHandle *)jarg1;
72912   if (!argp1) {
72913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72914     return 0;
72915   }
72916   arg1 = *argp1;
72917   {
72918     try {
72919       result = Dali::Toolkit::Scrollable::DownCast(arg1);
72920     } catch (std::out_of_range& e) {
72921       {
72922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72923       };
72924     } catch (std::exception& e) {
72925       {
72926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72927       };
72928     } catch (Dali::DaliException e) {
72929       {
72930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72931       };
72932     } catch (...) {
72933       {
72934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72935       };
72936     }
72937   }
72938
72939   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
72940   return jresult;
72941 }
72942
72943
72944 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
72945   unsigned int jresult ;
72946   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72947   bool result;
72948
72949   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72950   {
72951     try {
72952       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
72953     } catch (std::out_of_range& e) {
72954       {
72955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72956       };
72957     } catch (std::exception& e) {
72958       {
72959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72960       };
72961     } catch (Dali::DaliException e) {
72962       {
72963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72964       };
72965     } catch (...) {
72966       {
72967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72968       };
72969     }
72970   }
72971
72972   jresult = result;
72973   return jresult;
72974 }
72975
72976
72977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
72978   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72979   bool arg2 ;
72980
72981   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72982   arg2 = jarg2 ? true : false;
72983   {
72984     try {
72985       (arg1)->SetOvershootEnabled(arg2);
72986     } catch (std::out_of_range& e) {
72987       {
72988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72989       };
72990     } catch (std::exception& e) {
72991       {
72992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72993       };
72994     } catch (Dali::DaliException e) {
72995       {
72996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72997       };
72998     } catch (...) {
72999       {
73000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73001       };
73002     }
73003   }
73004
73005 }
73006
73007
73008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
73009   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73010   Dali::Vector4 *arg2 = 0 ;
73011
73012   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73013   arg2 = (Dali::Vector4 *)jarg2;
73014   if (!arg2) {
73015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
73016     return ;
73017   }
73018   {
73019     try {
73020       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
73021     } catch (std::out_of_range& e) {
73022       {
73023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73024       };
73025     } catch (std::exception& e) {
73026       {
73027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73028       };
73029     } catch (Dali::DaliException e) {
73030       {
73031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73032       };
73033     } catch (...) {
73034       {
73035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73036       };
73037     }
73038   }
73039
73040 }
73041
73042
73043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
73044   void * jresult ;
73045   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73046   Dali::Vector4 result;
73047
73048   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73049   {
73050     try {
73051       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
73052     } catch (std::out_of_range& e) {
73053       {
73054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73055       };
73056     } catch (std::exception& e) {
73057       {
73058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73059       };
73060     } catch (Dali::DaliException e) {
73061       {
73062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73063       };
73064     } catch (...) {
73065       {
73066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73067       };
73068     }
73069   }
73070
73071   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
73072   return jresult;
73073 }
73074
73075
73076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
73077   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73078   float arg2 ;
73079
73080   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73081   arg2 = (float)jarg2;
73082   {
73083     try {
73084       (arg1)->SetOvershootAnimationSpeed(arg2);
73085     } catch (std::out_of_range& e) {
73086       {
73087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73088       };
73089     } catch (std::exception& e) {
73090       {
73091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73092       };
73093     } catch (Dali::DaliException e) {
73094       {
73095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73096       };
73097     } catch (...) {
73098       {
73099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73100       };
73101     }
73102   }
73103
73104 }
73105
73106
73107 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
73108   float jresult ;
73109   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73110   float result;
73111
73112   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73113   {
73114     try {
73115       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
73116     } catch (std::out_of_range& e) {
73117       {
73118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73119       };
73120     } catch (std::exception& e) {
73121       {
73122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73123       };
73124     } catch (Dali::DaliException e) {
73125       {
73126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73127       };
73128     } catch (...) {
73129       {
73130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73131       };
73132     }
73133   }
73134
73135   jresult = result;
73136   return jresult;
73137 }
73138
73139
73140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
73141   void * jresult ;
73142   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73143   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
73144
73145   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73146   {
73147     try {
73148       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
73149     } catch (std::out_of_range& e) {
73150       {
73151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73152       };
73153     } catch (std::exception& e) {
73154       {
73155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73156       };
73157     } catch (Dali::DaliException e) {
73158       {
73159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73160       };
73161     } catch (...) {
73162       {
73163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73164       };
73165     }
73166   }
73167
73168   jresult = (void *)result;
73169   return jresult;
73170 }
73171
73172
73173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
73174   void * jresult ;
73175   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73176   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
73177
73178   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73179   {
73180     try {
73181       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
73182     } catch (std::out_of_range& e) {
73183       {
73184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73185       };
73186     } catch (std::exception& e) {
73187       {
73188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73189       };
73190     } catch (Dali::DaliException e) {
73191       {
73192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73193       };
73194     } catch (...) {
73195       {
73196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73197       };
73198     }
73199   }
73200
73201   jresult = (void *)result;
73202   return jresult;
73203 }
73204
73205
73206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
73207   void * jresult ;
73208   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73209   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
73210
73211   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73212   {
73213     try {
73214       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
73215     } catch (std::out_of_range& e) {
73216       {
73217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73218       };
73219     } catch (std::exception& e) {
73220       {
73221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73222       };
73223     } catch (Dali::DaliException e) {
73224       {
73225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73226       };
73227     } catch (...) {
73228       {
73229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73230       };
73231     }
73232   }
73233
73234   jresult = (void *)result;
73235   return jresult;
73236 }
73237
73238
73239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
73240   unsigned int jresult ;
73241   Dali::Toolkit::ControlOrientation::Type arg1 ;
73242   bool result;
73243
73244   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
73245   {
73246     try {
73247       result = (bool)Dali::Toolkit::IsVertical(arg1);
73248     } catch (std::out_of_range& e) {
73249       {
73250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73251       };
73252     } catch (std::exception& e) {
73253       {
73254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73255       };
73256     } catch (Dali::DaliException e) {
73257       {
73258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73259       };
73260     } catch (...) {
73261       {
73262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73263       };
73264     }
73265   }
73266
73267   jresult = result;
73268   return jresult;
73269 }
73270
73271
73272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
73273   unsigned int jresult ;
73274   Dali::Toolkit::ControlOrientation::Type arg1 ;
73275   bool result;
73276
73277   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
73278   {
73279     try {
73280       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
73281     } catch (std::out_of_range& e) {
73282       {
73283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73284       };
73285     } catch (std::exception& e) {
73286       {
73287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73288       };
73289     } catch (Dali::DaliException e) {
73290       {
73291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73292       };
73293     } catch (...) {
73294       {
73295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73296       };
73297     }
73298   }
73299
73300   jresult = result;
73301   return jresult;
73302 }
73303
73304
73305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
73306   void * jresult ;
73307   unsigned int arg1 ;
73308   unsigned int arg2 ;
73309   Dali::Toolkit::ItemRange *result = 0 ;
73310
73311   arg1 = (unsigned int)jarg1;
73312   arg2 = (unsigned int)jarg2;
73313   {
73314     try {
73315       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
73316     } catch (std::out_of_range& e) {
73317       {
73318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73319       };
73320     } catch (std::exception& e) {
73321       {
73322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73323       };
73324     } catch (Dali::DaliException e) {
73325       {
73326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73327       };
73328     } catch (...) {
73329       {
73330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73331       };
73332     }
73333   }
73334
73335   jresult = (void *)result;
73336   return jresult;
73337 }
73338
73339
73340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
73341   void * jresult ;
73342   Dali::Toolkit::ItemRange *arg1 = 0 ;
73343   Dali::Toolkit::ItemRange *result = 0 ;
73344
73345   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73346   if (!arg1) {
73347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73348     return 0;
73349   }
73350   {
73351     try {
73352       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
73353     } catch (std::out_of_range& e) {
73354       {
73355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73356       };
73357     } catch (std::exception& e) {
73358       {
73359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73360       };
73361     } catch (Dali::DaliException e) {
73362       {
73363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73364       };
73365     } catch (...) {
73366       {
73367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73368       };
73369     }
73370   }
73371
73372   jresult = (void *)result;
73373   return jresult;
73374 }
73375
73376
73377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
73378   void * jresult ;
73379   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73380   Dali::Toolkit::ItemRange *arg2 = 0 ;
73381   Dali::Toolkit::ItemRange *result = 0 ;
73382
73383   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73384   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
73385   if (!arg2) {
73386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73387     return 0;
73388   }
73389   {
73390     try {
73391       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
73392     } catch (std::out_of_range& e) {
73393       {
73394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73395       };
73396     } catch (std::exception& e) {
73397       {
73398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73399       };
73400     } catch (Dali::DaliException e) {
73401       {
73402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73403       };
73404     } catch (...) {
73405       {
73406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73407       };
73408     }
73409   }
73410
73411   jresult = (void *)result;
73412   return jresult;
73413 }
73414
73415
73416 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
73417   unsigned int jresult ;
73418   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73419   unsigned int arg2 ;
73420   bool result;
73421
73422   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73423   arg2 = (unsigned int)jarg2;
73424   {
73425     try {
73426       result = (bool)(arg1)->Within(arg2);
73427     } catch (std::out_of_range& e) {
73428       {
73429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73430       };
73431     } catch (std::exception& e) {
73432       {
73433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73434       };
73435     } catch (Dali::DaliException e) {
73436       {
73437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73438       };
73439     } catch (...) {
73440       {
73441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73442       };
73443     }
73444   }
73445
73446   jresult = result;
73447   return jresult;
73448 }
73449
73450
73451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
73452   void * jresult ;
73453   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73454   Dali::Toolkit::ItemRange *arg2 = 0 ;
73455   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
73456
73457   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73458   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
73459   if (!arg2) {
73460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73461     return 0;
73462   }
73463   {
73464     try {
73465       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
73466     } catch (std::out_of_range& e) {
73467       {
73468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73469       };
73470     } catch (std::exception& e) {
73471       {
73472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73473       };
73474     } catch (Dali::DaliException e) {
73475       {
73476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73477       };
73478     } catch (...) {
73479       {
73480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73481       };
73482     }
73483   }
73484
73485   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
73486   return jresult;
73487 }
73488
73489
73490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
73491   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73492   unsigned int arg2 ;
73493
73494   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73495   arg2 = (unsigned int)jarg2;
73496   if (arg1) (arg1)->begin = arg2;
73497 }
73498
73499
73500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
73501   unsigned int jresult ;
73502   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73503   unsigned int result;
73504
73505   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73506   result = (unsigned int) ((arg1)->begin);
73507   jresult = result;
73508   return jresult;
73509 }
73510
73511
73512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
73513   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73514   unsigned int arg2 ;
73515
73516   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73517   arg2 = (unsigned int)jarg2;
73518   if (arg1) (arg1)->end = arg2;
73519 }
73520
73521
73522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
73523   unsigned int jresult ;
73524   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73525   unsigned int result;
73526
73527   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73528   result = (unsigned int) ((arg1)->end);
73529   jresult = result;
73530   return jresult;
73531 }
73532
73533
73534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
73535   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73536
73537   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73538   {
73539     try {
73540       delete arg1;
73541     } catch (std::out_of_range& e) {
73542       {
73543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73544       };
73545     } catch (std::exception& e) {
73546       {
73547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73548       };
73549     } catch (Dali::DaliException e) {
73550       {
73551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73552       };
73553     } catch (...) {
73554       {
73555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73556       };
73557     }
73558   }
73559
73560 }
73561
73562
73563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
73564   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73565
73566   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73567   {
73568     try {
73569       delete arg1;
73570     } catch (std::out_of_range& e) {
73571       {
73572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73573       };
73574     } catch (std::exception& e) {
73575       {
73576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73577       };
73578     } catch (Dali::DaliException e) {
73579       {
73580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73581       };
73582     } catch (...) {
73583       {
73584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73585       };
73586     }
73587   }
73588
73589 }
73590
73591
73592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
73593   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73594   Dali::Toolkit::ControlOrientation::Type arg2 ;
73595
73596   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73597   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
73598   {
73599     try {
73600       (arg1)->SetOrientation(arg2);
73601     } catch (std::out_of_range& e) {
73602       {
73603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73604       };
73605     } catch (std::exception& e) {
73606       {
73607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73608       };
73609     } catch (Dali::DaliException e) {
73610       {
73611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73612       };
73613     } catch (...) {
73614       {
73615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73616       };
73617     }
73618   }
73619
73620 }
73621
73622
73623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
73624   int jresult ;
73625   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73626   Dali::Toolkit::ControlOrientation::Type result;
73627
73628   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73629   {
73630     try {
73631       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
73632     } catch (std::out_of_range& e) {
73633       {
73634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73635       };
73636     } catch (std::exception& e) {
73637       {
73638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73639       };
73640     } catch (Dali::DaliException e) {
73641       {
73642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73643       };
73644     } catch (...) {
73645       {
73646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73647       };
73648     }
73649   }
73650
73651   jresult = (int)result;
73652   return jresult;
73653 }
73654
73655
73656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
73657   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73658   Dali::Property::Map *arg2 = 0 ;
73659
73660   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73661   arg2 = (Dali::Property::Map *)jarg2;
73662   if (!arg2) {
73663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
73664     return ;
73665   }
73666   {
73667     try {
73668       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
73669     } catch (std::out_of_range& e) {
73670       {
73671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73672       };
73673     } catch (std::exception& e) {
73674       {
73675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73676       };
73677     } catch (Dali::DaliException e) {
73678       {
73679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73680       };
73681     } catch (...) {
73682       {
73683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73684       };
73685     }
73686   }
73687
73688 }
73689
73690
73691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
73692   void * jresult ;
73693   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73694   Dali::Property::Map result;
73695
73696   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73697   {
73698     try {
73699       result = (arg1)->GetLayoutProperties();
73700     } catch (std::out_of_range& e) {
73701       {
73702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73703       };
73704     } catch (std::exception& e) {
73705       {
73706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73707       };
73708     } catch (Dali::DaliException e) {
73709       {
73710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73711       };
73712     } catch (...) {
73713       {
73714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73715       };
73716     }
73717   }
73718
73719   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
73720   return jresult;
73721 }
73722
73723
73724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
73725   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73726   unsigned int arg2 ;
73727   Dali::Vector3 *arg3 = 0 ;
73728   Dali::Vector3 *arg4 = 0 ;
73729
73730   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73731   arg2 = (unsigned int)jarg2;
73732   arg3 = (Dali::Vector3 *)jarg3;
73733   if (!arg3) {
73734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73735     return ;
73736   }
73737   arg4 = (Dali::Vector3 *)jarg4;
73738   if (!arg4) {
73739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
73740     return ;
73741   }
73742   {
73743     try {
73744       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
73745     } catch (std::out_of_range& e) {
73746       {
73747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73748       };
73749     } catch (std::exception& e) {
73750       {
73751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73752       };
73753     } catch (Dali::DaliException e) {
73754       {
73755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73756       };
73757     } catch (...) {
73758       {
73759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73760       };
73761     }
73762   }
73763
73764 }
73765
73766
73767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
73768   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73769   Dali::Vector3 *arg2 = 0 ;
73770
73771   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73772   arg2 = (Dali::Vector3 *)jarg2;
73773   if (!arg2) {
73774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73775     return ;
73776   }
73777   {
73778     try {
73779       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
73780     } catch (std::out_of_range& e) {
73781       {
73782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73783       };
73784     } catch (std::exception& e) {
73785       {
73786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73787       };
73788     } catch (Dali::DaliException e) {
73789       {
73790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73791       };
73792     } catch (...) {
73793       {
73794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73795       };
73796     }
73797   }
73798
73799 }
73800
73801
73802 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
73803   float jresult ;
73804   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73805   unsigned int arg2 ;
73806   Dali::Vector3 arg3 ;
73807   Dali::Vector3 *argp3 ;
73808   float result;
73809
73810   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73811   arg2 = (unsigned int)jarg2;
73812   argp3 = (Dali::Vector3 *)jarg3;
73813   if (!argp3) {
73814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
73815     return 0;
73816   }
73817   arg3 = *argp3;
73818   {
73819     try {
73820       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
73821     } catch (std::out_of_range& e) {
73822       {
73823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73824       };
73825     } catch (std::exception& e) {
73826       {
73827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73828       };
73829     } catch (Dali::DaliException e) {
73830       {
73831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73832       };
73833     } catch (...) {
73834       {
73835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73836       };
73837     }
73838   }
73839
73840   jresult = result;
73841   return jresult;
73842 }
73843
73844
73845 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
73846   float jresult ;
73847   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73848   float arg2 ;
73849   float result;
73850
73851   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73852   arg2 = (float)jarg2;
73853   {
73854     try {
73855       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
73856     } catch (std::out_of_range& e) {
73857       {
73858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73859       };
73860     } catch (std::exception& e) {
73861       {
73862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73863       };
73864     } catch (Dali::DaliException e) {
73865       {
73866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73867       };
73868     } catch (...) {
73869       {
73870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73871       };
73872     }
73873   }
73874
73875   jresult = result;
73876   return jresult;
73877 }
73878
73879
73880 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
73881   float jresult ;
73882   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73883   unsigned int arg2 ;
73884   float result;
73885
73886   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73887   arg2 = (unsigned int)jarg2;
73888   {
73889     try {
73890       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
73891     } catch (std::out_of_range& e) {
73892       {
73893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73894       };
73895     } catch (std::exception& e) {
73896       {
73897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73898       };
73899     } catch (Dali::DaliException e) {
73900       {
73901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73902       };
73903     } catch (...) {
73904       {
73905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73906       };
73907     }
73908   }
73909
73910   jresult = result;
73911   return jresult;
73912 }
73913
73914
73915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
73916   void * jresult ;
73917   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73918   float arg2 ;
73919   Dali::Vector3 arg3 ;
73920   Dali::Vector3 *argp3 ;
73921   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
73922
73923   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73924   arg2 = (float)jarg2;
73925   argp3 = (Dali::Vector3 *)jarg3;
73926   if (!argp3) {
73927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
73928     return 0;
73929   }
73930   arg3 = *argp3;
73931   {
73932     try {
73933       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
73934     } catch (std::out_of_range& e) {
73935       {
73936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73937       };
73938     } catch (std::exception& e) {
73939       {
73940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73941       };
73942     } catch (Dali::DaliException e) {
73943       {
73944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73945       };
73946     } catch (...) {
73947       {
73948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73949       };
73950     }
73951   }
73952
73953   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
73954   return jresult;
73955 }
73956
73957
73958 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
73959   float jresult ;
73960   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73961   int arg2 ;
73962   float arg3 ;
73963   Dali::Vector3 *arg4 = 0 ;
73964   float result;
73965
73966   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73967   arg2 = (int)jarg2;
73968   arg3 = (float)jarg3;
73969   arg4 = (Dali::Vector3 *)jarg4;
73970   if (!arg4) {
73971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73972     return 0;
73973   }
73974   {
73975     try {
73976       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
73977     } catch (std::out_of_range& e) {
73978       {
73979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73980       };
73981     } catch (std::exception& e) {
73982       {
73983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73984       };
73985     } catch (Dali::DaliException e) {
73986       {
73987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73988       };
73989     } catch (...) {
73990       {
73991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73992       };
73993     }
73994   }
73995
73996   jresult = result;
73997   return jresult;
73998 }
73999
74000
74001 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
74002   unsigned int jresult ;
74003   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74004   Dali::Vector3 arg2 ;
74005   Dali::Vector3 *argp2 ;
74006   unsigned int result;
74007
74008   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74009   argp2 = (Dali::Vector3 *)jarg2;
74010   if (!argp2) {
74011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74012     return 0;
74013   }
74014   arg2 = *argp2;
74015   {
74016     try {
74017       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
74018     } catch (std::out_of_range& e) {
74019       {
74020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74021       };
74022     } catch (std::exception& e) {
74023       {
74024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74025       };
74026     } catch (Dali::DaliException e) {
74027       {
74028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74029       };
74030     } catch (...) {
74031       {
74032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74033       };
74034     }
74035   }
74036
74037   jresult = result;
74038   return jresult;
74039 }
74040
74041
74042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74043   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74044   unsigned int arg2 ;
74045   Dali::Vector3 *arg3 = 0 ;
74046   Dali::Vector3 *arg4 = 0 ;
74047
74048   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74049   arg2 = (unsigned int)jarg2;
74050   arg3 = (Dali::Vector3 *)jarg3;
74051   if (!arg3) {
74052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74053     return ;
74054   }
74055   arg4 = (Dali::Vector3 *)jarg4;
74056   if (!arg4) {
74057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74058     return ;
74059   }
74060   {
74061     try {
74062       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74063     } catch (std::out_of_range& e) {
74064       {
74065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74066       };
74067     } catch (std::exception& e) {
74068       {
74069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74070       };
74071     } catch (Dali::DaliException e) {
74072       {
74073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74074       };
74075     } catch (...) {
74076       {
74077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74078       };
74079     }
74080   }
74081
74082 }
74083
74084
74085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
74086   void * jresult ;
74087   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74088   Dali::Degree result;
74089
74090   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74091   {
74092     try {
74093       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
74094     } catch (std::out_of_range& e) {
74095       {
74096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74097       };
74098     } catch (std::exception& e) {
74099       {
74100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74101       };
74102     } catch (Dali::DaliException e) {
74103       {
74104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74105       };
74106     } catch (...) {
74107       {
74108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74109       };
74110     }
74111   }
74112
74113   jresult = new Dali::Degree((const Dali::Degree &)result);
74114   return jresult;
74115 }
74116
74117
74118 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
74119   float jresult ;
74120   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74121   float result;
74122
74123   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74124   {
74125     try {
74126       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
74127     } catch (std::out_of_range& e) {
74128       {
74129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74130       };
74131     } catch (std::exception& e) {
74132       {
74133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74134       };
74135     } catch (Dali::DaliException e) {
74136       {
74137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74138       };
74139     } catch (...) {
74140       {
74141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74142       };
74143     }
74144   }
74145
74146   jresult = result;
74147   return jresult;
74148 }
74149
74150
74151 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
74152   float jresult ;
74153   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74154   float result;
74155
74156   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74157   {
74158     try {
74159       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
74160     } catch (std::out_of_range& e) {
74161       {
74162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74163       };
74164     } catch (std::exception& e) {
74165       {
74166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74167       };
74168     } catch (Dali::DaliException e) {
74169       {
74170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74171       };
74172     } catch (...) {
74173       {
74174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74175       };
74176     }
74177   }
74178
74179   jresult = result;
74180   return jresult;
74181 }
74182
74183
74184 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
74185   float jresult ;
74186   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74187   float result;
74188
74189   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74190   {
74191     try {
74192       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
74193     } catch (std::out_of_range& e) {
74194       {
74195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74196       };
74197     } catch (std::exception& e) {
74198       {
74199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74200       };
74201     } catch (Dali::DaliException e) {
74202       {
74203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74204       };
74205     } catch (...) {
74206       {
74207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74208       };
74209     }
74210   }
74211
74212   jresult = result;
74213   return jresult;
74214 }
74215
74216
74217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
74218   int jresult ;
74219   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74220   int arg2 ;
74221   int arg3 ;
74222   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
74223   bool arg5 ;
74224   int result;
74225
74226   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74227   arg2 = (int)jarg2;
74228   arg3 = (int)jarg3;
74229   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
74230   arg5 = jarg5 ? true : false;
74231   {
74232     try {
74233       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
74234     } catch (std::out_of_range& e) {
74235       {
74236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74237       };
74238     } catch (std::exception& e) {
74239       {
74240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74241       };
74242     } catch (Dali::DaliException e) {
74243       {
74244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74245       };
74246     } catch (...) {
74247       {
74248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74249       };
74250     }
74251   }
74252
74253   jresult = result;
74254   return jresult;
74255 }
74256
74257
74258 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
74259   float jresult ;
74260   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74261   float result;
74262
74263   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74264   {
74265     try {
74266       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
74267     } catch (std::out_of_range& e) {
74268       {
74269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74270       };
74271     } catch (std::exception& e) {
74272       {
74273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74274       };
74275     } catch (Dali::DaliException e) {
74276       {
74277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74278       };
74279     } catch (...) {
74280       {
74281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74282       };
74283     }
74284   }
74285
74286   jresult = result;
74287   return jresult;
74288 }
74289
74290
74291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
74292   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74293   Dali::Actor *arg2 = 0 ;
74294   int arg3 ;
74295   Dali::Vector3 *arg4 = 0 ;
74296   Dali::Actor *arg5 = 0 ;
74297
74298   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74299   arg2 = (Dali::Actor *)jarg2;
74300   if (!arg2) {
74301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74302     return ;
74303   }
74304   arg3 = (int)jarg3;
74305   arg4 = (Dali::Vector3 *)jarg4;
74306   if (!arg4) {
74307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74308     return ;
74309   }
74310   arg5 = (Dali::Actor *)jarg5;
74311   if (!arg5) {
74312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
74313     return ;
74314   }
74315   {
74316     try {
74317       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
74318     } catch (std::out_of_range& e) {
74319       {
74320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74321       };
74322     } catch (std::exception& e) {
74323       {
74324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74325       };
74326     } catch (Dali::DaliException e) {
74327       {
74328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74329       };
74330     } catch (...) {
74331       {
74332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74333       };
74334     }
74335   }
74336
74337 }
74338
74339
74340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
74341   void * jresult ;
74342   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74343   int arg2 ;
74344   float arg3 ;
74345   Dali::Vector3 *arg4 = 0 ;
74346   Dali::Vector3 result;
74347
74348   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74349   arg2 = (int)jarg2;
74350   arg3 = (float)jarg3;
74351   arg4 = (Dali::Vector3 *)jarg4;
74352   if (!arg4) {
74353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74354     return 0;
74355   }
74356   {
74357     try {
74358       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
74359     } catch (std::out_of_range& e) {
74360       {
74361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74362       };
74363     } catch (std::exception& e) {
74364       {
74365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74366       };
74367     } catch (Dali::DaliException e) {
74368       {
74369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74370       };
74371     } catch (...) {
74372       {
74373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74374       };
74375     }
74376   }
74377
74378   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
74379   return jresult;
74380 }
74381
74382
74383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
74384   void * jresult ;
74385   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
74386   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
74387
74388   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
74389   {
74390     try {
74391       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
74392     } catch (std::out_of_range& e) {
74393       {
74394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74395       };
74396     } catch (std::exception& e) {
74397       {
74398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74399       };
74400     } catch (Dali::DaliException e) {
74401       {
74402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74403       };
74404     } catch (...) {
74405       {
74406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74407       };
74408     }
74409   }
74410
74411   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
74412   return jresult;
74413 }
74414
74415
74416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
74417   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74418
74419   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74420   {
74421     try {
74422       delete arg1;
74423     } catch (std::out_of_range& e) {
74424       {
74425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74426       };
74427     } catch (std::exception& e) {
74428       {
74429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74430       };
74431     } catch (Dali::DaliException e) {
74432       {
74433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74434       };
74435     } catch (...) {
74436       {
74437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74438       };
74439     }
74440   }
74441
74442 }
74443
74444
74445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
74446   unsigned int jresult ;
74447   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74448   unsigned int result;
74449
74450   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74451   {
74452     try {
74453       result = (unsigned int)(arg1)->GetNumberOfItems();
74454     } catch (std::out_of_range& e) {
74455       {
74456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74457       };
74458     } catch (std::exception& e) {
74459       {
74460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74461       };
74462     } catch (Dali::DaliException e) {
74463       {
74464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74465       };
74466     } catch (...) {
74467       {
74468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74469       };
74470     }
74471   }
74472
74473   jresult = result;
74474   return jresult;
74475 }
74476
74477
74478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
74479   void * jresult ;
74480   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74481   unsigned int arg2 ;
74482   Dali::Actor result;
74483
74484   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74485   arg2 = (unsigned int)jarg2;
74486   {
74487     try {
74488       result = (arg1)->NewItem(arg2);
74489     } catch (std::out_of_range& e) {
74490       {
74491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74492       };
74493     } catch (std::exception& e) {
74494       {
74495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74496       };
74497     } catch (Dali::DaliException e) {
74498       {
74499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74500       };
74501     } catch (...) {
74502       {
74503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74504       };
74505     }
74506   }
74507
74508   jresult = new Dali::Actor((const Dali::Actor &)result);
74509   return jresult;
74510 }
74511
74512
74513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
74514   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74515   unsigned int arg2 ;
74516   Dali::Actor arg3 ;
74517   Dali::Actor *argp3 ;
74518
74519   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74520   arg2 = (unsigned int)jarg2;
74521   argp3 = (Dali::Actor *)jarg3;
74522   if (!argp3) {
74523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74524     return ;
74525   }
74526   arg3 = *argp3;
74527   {
74528     try {
74529       (arg1)->ItemReleased(arg2,arg3);
74530     } catch (std::out_of_range& e) {
74531       {
74532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74533       };
74534     } catch (std::exception& e) {
74535       {
74536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74537       };
74538     } catch (Dali::DaliException e) {
74539       {
74540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74541       };
74542     } catch (...) {
74543       {
74544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74545       };
74546     }
74547   }
74548
74549 }
74550
74551
74552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
74553   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74554   unsigned int arg2 ;
74555   Dali::Actor arg3 ;
74556   Dali::Actor *argp3 ;
74557
74558   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74559   arg2 = (unsigned int)jarg2;
74560   argp3 = (Dali::Actor *)jarg3;
74561   if (!argp3) {
74562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74563     return ;
74564   }
74565   arg3 = *argp3;
74566   {
74567     try {
74568       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
74569     } catch (std::out_of_range& e) {
74570       {
74571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74572       };
74573     } catch (std::exception& e) {
74574       {
74575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74576       };
74577     } catch (Dali::DaliException e) {
74578       {
74579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74580       };
74581     } catch (...) {
74582       {
74583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74584       };
74585     }
74586   }
74587
74588 }
74589
74590
74591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
74592   void * jresult ;
74593   Dali::Toolkit::ItemFactory *result = 0 ;
74594
74595   {
74596     try {
74597       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
74598     } catch (std::out_of_range& e) {
74599       {
74600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74601       };
74602     } catch (std::exception& e) {
74603       {
74604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74605       };
74606     } catch (Dali::DaliException e) {
74607       {
74608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74609       };
74610     } catch (...) {
74611       {
74612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74613       };
74614     }
74615   }
74616
74617   jresult = (void *)result;
74618   return jresult;
74619 }
74620
74621
74622 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) {
74623   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
74624   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
74625   if (director) {
74626     director->swig_connect_director(callback0, callback1, callback2);
74627   }
74628 }
74629
74630
74631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
74632   int jresult ;
74633   int result;
74634
74635   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
74636   jresult = (int)result;
74637   return jresult;
74638 }
74639
74640
74641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
74642   int jresult ;
74643   int result;
74644
74645   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
74646   jresult = (int)result;
74647   return jresult;
74648 }
74649
74650
74651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74652   int jresult ;
74653   int result;
74654
74655   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74656   jresult = (int)result;
74657   return jresult;
74658 }
74659
74660
74661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
74662   int jresult ;
74663   int result;
74664
74665   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
74666   jresult = (int)result;
74667   return jresult;
74668 }
74669
74670
74671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
74672   int jresult ;
74673   int result;
74674
74675   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
74676   jresult = (int)result;
74677   return jresult;
74678 }
74679
74680
74681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
74682   int jresult ;
74683   int result;
74684
74685   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
74686   jresult = (int)result;
74687   return jresult;
74688 }
74689
74690
74691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
74692   int jresult ;
74693   int result;
74694
74695   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
74696   jresult = (int)result;
74697   return jresult;
74698 }
74699
74700
74701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
74702   int jresult ;
74703   int result;
74704
74705   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
74706   jresult = (int)result;
74707   return jresult;
74708 }
74709
74710
74711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
74712   int jresult ;
74713   int result;
74714
74715   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
74716   jresult = (int)result;
74717   return jresult;
74718 }
74719
74720
74721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
74722   int jresult ;
74723   int result;
74724
74725   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
74726   jresult = (int)result;
74727   return jresult;
74728 }
74729
74730
74731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
74732   int jresult ;
74733   int result;
74734
74735   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
74736   jresult = (int)result;
74737   return jresult;
74738 }
74739
74740
74741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
74742   void * jresult ;
74743   Dali::Toolkit::ItemView::Property *result = 0 ;
74744
74745   {
74746     try {
74747       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
74748     } catch (std::out_of_range& e) {
74749       {
74750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74751       };
74752     } catch (std::exception& e) {
74753       {
74754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74755       };
74756     } catch (Dali::DaliException e) {
74757       {
74758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74759       };
74760     } catch (...) {
74761       {
74762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74763       };
74764     }
74765   }
74766
74767   jresult = (void *)result;
74768   return jresult;
74769 }
74770
74771
74772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
74773   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
74774
74775   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
74776   {
74777     try {
74778       delete arg1;
74779     } catch (std::out_of_range& e) {
74780       {
74781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74782       };
74783     } catch (std::exception& e) {
74784       {
74785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74786       };
74787     } catch (Dali::DaliException e) {
74788       {
74789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74790       };
74791     } catch (...) {
74792       {
74793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74794       };
74795     }
74796   }
74797
74798 }
74799
74800
74801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
74802   void * jresult ;
74803   Dali::Toolkit::ItemView *result = 0 ;
74804
74805   {
74806     try {
74807       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
74808     } catch (std::out_of_range& e) {
74809       {
74810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74811       };
74812     } catch (std::exception& e) {
74813       {
74814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74815       };
74816     } catch (Dali::DaliException e) {
74817       {
74818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74819       };
74820     } catch (...) {
74821       {
74822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74823       };
74824     }
74825   }
74826
74827   jresult = (void *)result;
74828   return jresult;
74829 }
74830
74831
74832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
74833   void * jresult ;
74834   Dali::Toolkit::ItemView *arg1 = 0 ;
74835   Dali::Toolkit::ItemView *result = 0 ;
74836
74837   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74838   if (!arg1) {
74839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
74840     return 0;
74841   }
74842   {
74843     try {
74844       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
74845     } catch (std::out_of_range& e) {
74846       {
74847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74848       };
74849     } catch (std::exception& e) {
74850       {
74851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74852       };
74853     } catch (Dali::DaliException e) {
74854       {
74855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74856       };
74857     } catch (...) {
74858       {
74859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74860       };
74861     }
74862   }
74863
74864   jresult = (void *)result;
74865   return jresult;
74866 }
74867
74868
74869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
74870   void * jresult ;
74871   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74872   Dali::Toolkit::ItemView *arg2 = 0 ;
74873   Dali::Toolkit::ItemView *result = 0 ;
74874
74875   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74876   arg2 = (Dali::Toolkit::ItemView *)jarg2;
74877   if (!arg2) {
74878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
74879     return 0;
74880   }
74881   {
74882     try {
74883       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
74884     } catch (std::out_of_range& e) {
74885       {
74886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74887       };
74888     } catch (std::exception& e) {
74889       {
74890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74891       };
74892     } catch (Dali::DaliException e) {
74893       {
74894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74895       };
74896     } catch (...) {
74897       {
74898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74899       };
74900     }
74901   }
74902
74903   jresult = (void *)result;
74904   return jresult;
74905 }
74906
74907
74908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
74909   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74910
74911   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74912   {
74913     try {
74914       delete arg1;
74915     } catch (std::out_of_range& e) {
74916       {
74917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74918       };
74919     } catch (std::exception& e) {
74920       {
74921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74922       };
74923     } catch (Dali::DaliException e) {
74924       {
74925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74926       };
74927     } catch (...) {
74928       {
74929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74930       };
74931     }
74932   }
74933
74934 }
74935
74936
74937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
74938   void * jresult ;
74939   Dali::Toolkit::ItemFactory *arg1 = 0 ;
74940   Dali::Toolkit::ItemView result;
74941
74942   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74943   if (!arg1) {
74944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
74945     return 0;
74946   }
74947   {
74948     try {
74949       result = Dali::Toolkit::ItemView::New(*arg1);
74950     } catch (std::out_of_range& e) {
74951       {
74952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74953       };
74954     } catch (std::exception& e) {
74955       {
74956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74957       };
74958     } catch (Dali::DaliException e) {
74959       {
74960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74961       };
74962     } catch (...) {
74963       {
74964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74965       };
74966     }
74967   }
74968
74969   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
74970   return jresult;
74971 }
74972
74973
74974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
74975   void * jresult ;
74976   Dali::BaseHandle arg1 ;
74977   Dali::BaseHandle *argp1 ;
74978   Dali::Toolkit::ItemView result;
74979
74980   argp1 = (Dali::BaseHandle *)jarg1;
74981   if (!argp1) {
74982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74983     return 0;
74984   }
74985   arg1 = *argp1;
74986   {
74987     try {
74988       result = Dali::Toolkit::ItemView::DownCast(arg1);
74989     } catch (std::out_of_range& e) {
74990       {
74991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74992       };
74993     } catch (std::exception& e) {
74994       {
74995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74996       };
74997     } catch (Dali::DaliException e) {
74998       {
74999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75000       };
75001     } catch (...) {
75002       {
75003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75004       };
75005     }
75006   }
75007
75008   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
75009   return jresult;
75010 }
75011
75012
75013 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
75014   unsigned int jresult ;
75015   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75016   unsigned int result;
75017
75018   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75019   {
75020     try {
75021       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
75022     } catch (std::out_of_range& e) {
75023       {
75024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75025       };
75026     } catch (std::exception& e) {
75027       {
75028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75029       };
75030     } catch (Dali::DaliException e) {
75031       {
75032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75033       };
75034     } catch (...) {
75035       {
75036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75037       };
75038     }
75039   }
75040
75041   jresult = result;
75042   return jresult;
75043 }
75044
75045
75046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
75047   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75048   Dali::Toolkit::ItemLayout *arg2 = 0 ;
75049
75050   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75051   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
75052   if (!arg2) {
75053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
75054     return ;
75055   }
75056   {
75057     try {
75058       (arg1)->AddLayout(*arg2);
75059     } catch (std::out_of_range& e) {
75060       {
75061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75062       };
75063     } catch (std::exception& e) {
75064       {
75065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75066       };
75067     } catch (Dali::DaliException e) {
75068       {
75069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75070       };
75071     } catch (...) {
75072       {
75073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75074       };
75075     }
75076   }
75077
75078 }
75079
75080
75081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
75082   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75083   unsigned int arg2 ;
75084
75085   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75086   arg2 = (unsigned int)jarg2;
75087   {
75088     try {
75089       (arg1)->RemoveLayout(arg2);
75090     } catch (std::out_of_range& e) {
75091       {
75092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75093       };
75094     } catch (std::exception& e) {
75095       {
75096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75097       };
75098     } catch (Dali::DaliException e) {
75099       {
75100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75101       };
75102     } catch (...) {
75103       {
75104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75105       };
75106     }
75107   }
75108
75109 }
75110
75111
75112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
75113   void * jresult ;
75114   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75115   unsigned int arg2 ;
75116   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75117
75118   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75119   arg2 = (unsigned int)jarg2;
75120   {
75121     try {
75122       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
75123     } catch (std::out_of_range& e) {
75124       {
75125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75126       };
75127     } catch (std::exception& e) {
75128       {
75129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75130       };
75131     } catch (Dali::DaliException e) {
75132       {
75133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75134       };
75135     } catch (...) {
75136       {
75137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75138       };
75139     }
75140   }
75141
75142   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75143   return jresult;
75144 }
75145
75146
75147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
75148   void * jresult ;
75149   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75150   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75151
75152   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75153   {
75154     try {
75155       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
75156     } catch (std::out_of_range& e) {
75157       {
75158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75159       };
75160     } catch (std::exception& e) {
75161       {
75162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75163       };
75164     } catch (Dali::DaliException e) {
75165       {
75166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75167       };
75168     } catch (...) {
75169       {
75170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75171       };
75172     }
75173   }
75174
75175   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75176   return jresult;
75177 }
75178
75179
75180 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
75181   float jresult ;
75182   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75183   Dali::Toolkit::ItemId arg2 ;
75184   float result;
75185
75186   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75187   arg2 = (Dali::Toolkit::ItemId)jarg2;
75188   {
75189     try {
75190       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
75191     } catch (std::out_of_range& e) {
75192       {
75193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75194       };
75195     } catch (std::exception& e) {
75196       {
75197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75198       };
75199     } catch (Dali::DaliException e) {
75200       {
75201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75202       };
75203     } catch (...) {
75204       {
75205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75206       };
75207     }
75208   }
75209
75210   jresult = result;
75211   return jresult;
75212 }
75213
75214
75215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
75216   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75217   unsigned int arg2 ;
75218   Dali::Vector3 arg3 ;
75219   float arg4 ;
75220   Dali::Vector3 *argp3 ;
75221
75222   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75223   arg2 = (unsigned int)jarg2;
75224   argp3 = (Dali::Vector3 *)jarg3;
75225   if (!argp3) {
75226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75227     return ;
75228   }
75229   arg3 = *argp3;
75230   arg4 = (float)jarg4;
75231   {
75232     try {
75233       (arg1)->ActivateLayout(arg2,arg3,arg4);
75234     } catch (std::out_of_range& e) {
75235       {
75236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75237       };
75238     } catch (std::exception& e) {
75239       {
75240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75241       };
75242     } catch (Dali::DaliException e) {
75243       {
75244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75245       };
75246     } catch (...) {
75247       {
75248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75249       };
75250     }
75251   }
75252
75253 }
75254
75255
75256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
75257   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75258
75259   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75260   {
75261     try {
75262       (arg1)->DeactivateCurrentLayout();
75263     } catch (std::out_of_range& e) {
75264       {
75265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75266       };
75267     } catch (std::exception& e) {
75268       {
75269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75270       };
75271     } catch (Dali::DaliException e) {
75272       {
75273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75274       };
75275     } catch (...) {
75276       {
75277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75278       };
75279     }
75280   }
75281
75282 }
75283
75284
75285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
75286   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75287   float arg2 ;
75288
75289   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75290   arg2 = (float)jarg2;
75291   {
75292     try {
75293       (arg1)->SetMinimumSwipeSpeed(arg2);
75294     } catch (std::out_of_range& e) {
75295       {
75296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75297       };
75298     } catch (std::exception& e) {
75299       {
75300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75301       };
75302     } catch (Dali::DaliException e) {
75303       {
75304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75305       };
75306     } catch (...) {
75307       {
75308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75309       };
75310     }
75311   }
75312
75313 }
75314
75315
75316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
75317   float jresult ;
75318   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75319   float result;
75320
75321   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75322   {
75323     try {
75324       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
75325     } catch (std::out_of_range& e) {
75326       {
75327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75328       };
75329     } catch (std::exception& e) {
75330       {
75331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75332       };
75333     } catch (Dali::DaliException e) {
75334       {
75335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75336       };
75337     } catch (...) {
75338       {
75339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75340       };
75341     }
75342   }
75343
75344   jresult = result;
75345   return jresult;
75346 }
75347
75348
75349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
75350   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75351   float arg2 ;
75352
75353   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75354   arg2 = (float)jarg2;
75355   {
75356     try {
75357       (arg1)->SetMinimumSwipeDistance(arg2);
75358     } catch (std::out_of_range& e) {
75359       {
75360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75361       };
75362     } catch (std::exception& e) {
75363       {
75364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75365       };
75366     } catch (Dali::DaliException e) {
75367       {
75368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75369       };
75370     } catch (...) {
75371       {
75372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75373       };
75374     }
75375   }
75376
75377 }
75378
75379
75380 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
75381   float jresult ;
75382   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75383   float result;
75384
75385   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75386   {
75387     try {
75388       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
75389     } catch (std::out_of_range& e) {
75390       {
75391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75392       };
75393     } catch (std::exception& e) {
75394       {
75395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75396       };
75397     } catch (Dali::DaliException e) {
75398       {
75399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75400       };
75401     } catch (...) {
75402       {
75403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75404       };
75405     }
75406   }
75407
75408   jresult = result;
75409   return jresult;
75410 }
75411
75412
75413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
75414   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75415   float arg2 ;
75416
75417   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75418   arg2 = (float)jarg2;
75419   {
75420     try {
75421       (arg1)->SetWheelScrollDistanceStep(arg2);
75422     } catch (std::out_of_range& e) {
75423       {
75424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75425       };
75426     } catch (std::exception& e) {
75427       {
75428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75429       };
75430     } catch (Dali::DaliException e) {
75431       {
75432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75433       };
75434     } catch (...) {
75435       {
75436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75437       };
75438     }
75439   }
75440
75441 }
75442
75443
75444 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
75445   float jresult ;
75446   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75447   float result;
75448
75449   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75450   {
75451     try {
75452       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
75453     } catch (std::out_of_range& e) {
75454       {
75455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75456       };
75457     } catch (std::exception& e) {
75458       {
75459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75460       };
75461     } catch (Dali::DaliException e) {
75462       {
75463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75464       };
75465     } catch (...) {
75466       {
75467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75468       };
75469     }
75470   }
75471
75472   jresult = result;
75473   return jresult;
75474 }
75475
75476
75477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
75478   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75479   bool arg2 ;
75480
75481   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75482   arg2 = jarg2 ? true : false;
75483   {
75484     try {
75485       (arg1)->SetAnchoring(arg2);
75486     } catch (std::out_of_range& e) {
75487       {
75488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75489       };
75490     } catch (std::exception& e) {
75491       {
75492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75493       };
75494     } catch (Dali::DaliException e) {
75495       {
75496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75497       };
75498     } catch (...) {
75499       {
75500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75501       };
75502     }
75503   }
75504
75505 }
75506
75507 //// ========================= end of part 3 =============================
75508
75509 //// ========================== start part 4 ===============================
75510
75511
75512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
75513   unsigned int jresult ;
75514   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75515   bool result;
75516
75517   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75518   {
75519     try {
75520       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
75521     } catch (std::out_of_range& e) {
75522       {
75523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75524       };
75525     } catch (std::exception& e) {
75526       {
75527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75528       };
75529     } catch (Dali::DaliException e) {
75530       {
75531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75532       };
75533     } catch (...) {
75534       {
75535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75536       };
75537     }
75538   }
75539
75540   jresult = result;
75541   return jresult;
75542 }
75543
75544
75545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
75546   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75547   float arg2 ;
75548
75549   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75550   arg2 = (float)jarg2;
75551   {
75552     try {
75553       (arg1)->SetAnchoringDuration(arg2);
75554     } catch (std::out_of_range& e) {
75555       {
75556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75557       };
75558     } catch (std::exception& e) {
75559       {
75560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75561       };
75562     } catch (Dali::DaliException e) {
75563       {
75564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75565       };
75566     } catch (...) {
75567       {
75568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75569       };
75570     }
75571   }
75572
75573 }
75574
75575
75576 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
75577   float jresult ;
75578   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75579   float result;
75580
75581   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75582   {
75583     try {
75584       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
75585     } catch (std::out_of_range& e) {
75586       {
75587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75588       };
75589     } catch (std::exception& e) {
75590       {
75591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75592       };
75593     } catch (Dali::DaliException e) {
75594       {
75595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75596       };
75597     } catch (...) {
75598       {
75599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75600       };
75601     }
75602   }
75603
75604   jresult = result;
75605   return jresult;
75606 }
75607
75608
75609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
75610   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75611   Dali::Toolkit::ItemId arg2 ;
75612   float arg3 ;
75613
75614   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75615   arg2 = (Dali::Toolkit::ItemId)jarg2;
75616   arg3 = (float)jarg3;
75617   {
75618     try {
75619       (arg1)->ScrollToItem(arg2,arg3);
75620     } catch (std::out_of_range& e) {
75621       {
75622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75623       };
75624     } catch (std::exception& e) {
75625       {
75626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75627       };
75628     } catch (Dali::DaliException e) {
75629       {
75630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75631       };
75632     } catch (...) {
75633       {
75634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75635       };
75636     }
75637   }
75638
75639 }
75640
75641
75642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
75643   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75644   float arg2 ;
75645
75646   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75647   arg2 = (float)jarg2;
75648   {
75649     try {
75650       (arg1)->SetRefreshInterval(arg2);
75651     } catch (std::out_of_range& e) {
75652       {
75653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75654       };
75655     } catch (std::exception& e) {
75656       {
75657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75658       };
75659     } catch (Dali::DaliException e) {
75660       {
75661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75662       };
75663     } catch (...) {
75664       {
75665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75666       };
75667     }
75668   }
75669
75670 }
75671
75672
75673 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
75674   float jresult ;
75675   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75676   float result;
75677
75678   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75679   {
75680     try {
75681       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
75682     } catch (std::out_of_range& e) {
75683       {
75684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75685       };
75686     } catch (std::exception& e) {
75687       {
75688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75689       };
75690     } catch (Dali::DaliException e) {
75691       {
75692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75693       };
75694     } catch (...) {
75695       {
75696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75697       };
75698     }
75699   }
75700
75701   jresult = result;
75702   return jresult;
75703 }
75704
75705
75706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
75707   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75708
75709   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75710   {
75711     try {
75712       (arg1)->Refresh();
75713     } catch (std::out_of_range& e) {
75714       {
75715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75716       };
75717     } catch (std::exception& e) {
75718       {
75719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75720       };
75721     } catch (Dali::DaliException e) {
75722       {
75723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75724       };
75725     } catch (...) {
75726       {
75727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75728       };
75729     }
75730   }
75731
75732 }
75733
75734
75735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
75736   void * jresult ;
75737   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75738   Dali::Toolkit::ItemId arg2 ;
75739   Dali::Actor result;
75740
75741   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75742   arg2 = (Dali::Toolkit::ItemId)jarg2;
75743   {
75744     try {
75745       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
75746     } catch (std::out_of_range& e) {
75747       {
75748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75749       };
75750     } catch (std::exception& e) {
75751       {
75752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75753       };
75754     } catch (Dali::DaliException e) {
75755       {
75756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75757       };
75758     } catch (...) {
75759       {
75760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75761       };
75762     }
75763   }
75764
75765   jresult = new Dali::Actor((const Dali::Actor &)result);
75766   return jresult;
75767 }
75768
75769
75770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
75771   unsigned int jresult ;
75772   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75773   Dali::Actor arg2 ;
75774   Dali::Actor *argp2 ;
75775   Dali::Toolkit::ItemId result;
75776
75777   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75778   argp2 = (Dali::Actor *)jarg2;
75779   if (!argp2) {
75780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75781     return 0;
75782   }
75783   arg2 = *argp2;
75784   {
75785     try {
75786       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
75787     } catch (std::out_of_range& e) {
75788       {
75789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75790       };
75791     } catch (std::exception& e) {
75792       {
75793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75794       };
75795     } catch (Dali::DaliException e) {
75796       {
75797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75798       };
75799     } catch (...) {
75800       {
75801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75802       };
75803     }
75804   }
75805
75806   jresult = result;
75807   return jresult;
75808 }
75809
75810
75811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
75812   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75813   Dali::Toolkit::Item arg2 ;
75814   float arg3 ;
75815   Dali::Toolkit::Item *argp2 ;
75816
75817   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75818   argp2 = (Dali::Toolkit::Item *)jarg2;
75819   if (!argp2) {
75820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
75821     return ;
75822   }
75823   arg2 = *argp2;
75824   arg3 = (float)jarg3;
75825   {
75826     try {
75827       (arg1)->InsertItem(arg2,arg3);
75828     } catch (std::out_of_range& e) {
75829       {
75830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75831       };
75832     } catch (std::exception& e) {
75833       {
75834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75835       };
75836     } catch (Dali::DaliException e) {
75837       {
75838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75839       };
75840     } catch (...) {
75841       {
75842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75843       };
75844     }
75845   }
75846
75847 }
75848
75849
75850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
75851   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75852   Dali::Toolkit::ItemContainer *arg2 = 0 ;
75853   float arg3 ;
75854
75855   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75856   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
75857   if (!arg2) {
75858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
75859     return ;
75860   }
75861   arg3 = (float)jarg3;
75862   {
75863     try {
75864       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
75865     } catch (std::out_of_range& e) {
75866       {
75867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75868       };
75869     } catch (std::exception& e) {
75870       {
75871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75872       };
75873     } catch (Dali::DaliException e) {
75874       {
75875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75876       };
75877     } catch (...) {
75878       {
75879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75880       };
75881     }
75882   }
75883
75884 }
75885
75886
75887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
75888   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75889   Dali::Toolkit::ItemId arg2 ;
75890   float arg3 ;
75891
75892   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75893   arg2 = (Dali::Toolkit::ItemId)jarg2;
75894   arg3 = (float)jarg3;
75895   {
75896     try {
75897       (arg1)->RemoveItem(arg2,arg3);
75898     } catch (std::out_of_range& e) {
75899       {
75900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75901       };
75902     } catch (std::exception& e) {
75903       {
75904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75905       };
75906     } catch (Dali::DaliException e) {
75907       {
75908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75909       };
75910     } catch (...) {
75911       {
75912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75913       };
75914     }
75915   }
75916
75917 }
75918
75919
75920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
75921   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75922   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
75923   float arg3 ;
75924
75925   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75926   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
75927   if (!arg2) {
75928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
75929     return ;
75930   }
75931   arg3 = (float)jarg3;
75932   {
75933     try {
75934       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
75935     } catch (std::out_of_range& e) {
75936       {
75937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75938       };
75939     } catch (std::exception& e) {
75940       {
75941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75942       };
75943     } catch (Dali::DaliException e) {
75944       {
75945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75946       };
75947     } catch (...) {
75948       {
75949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75950       };
75951     }
75952   }
75953
75954 }
75955
75956
75957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
75958   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75959   Dali::Toolkit::Item arg2 ;
75960   float arg3 ;
75961   Dali::Toolkit::Item *argp2 ;
75962
75963   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75964   argp2 = (Dali::Toolkit::Item *)jarg2;
75965   if (!argp2) {
75966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
75967     return ;
75968   }
75969   arg2 = *argp2;
75970   arg3 = (float)jarg3;
75971   {
75972     try {
75973       (arg1)->ReplaceItem(arg2,arg3);
75974     } catch (std::out_of_range& e) {
75975       {
75976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75977       };
75978     } catch (std::exception& e) {
75979       {
75980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75981       };
75982     } catch (Dali::DaliException e) {
75983       {
75984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75985       };
75986     } catch (...) {
75987       {
75988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75989       };
75990     }
75991   }
75992
75993 }
75994
75995
75996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
75997   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75998   Dali::Toolkit::ItemContainer *arg2 = 0 ;
75999   float arg3 ;
76000
76001   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76002   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
76003   if (!arg2) {
76004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76005     return ;
76006   }
76007   arg3 = (float)jarg3;
76008   {
76009     try {
76010       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76011     } catch (std::out_of_range& e) {
76012       {
76013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76014       };
76015     } catch (std::exception& e) {
76016       {
76017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76018       };
76019     } catch (Dali::DaliException e) {
76020       {
76021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76022       };
76023     } catch (...) {
76024       {
76025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76026       };
76027     }
76028   }
76029
76030 }
76031
76032
76033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
76034   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76035   Dali::Vector3 *arg2 = 0 ;
76036
76037   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76038   arg2 = (Dali::Vector3 *)jarg2;
76039   if (!arg2) {
76040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76041     return ;
76042   }
76043   {
76044     try {
76045       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
76046     } catch (std::out_of_range& e) {
76047       {
76048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76049       };
76050     } catch (std::exception& e) {
76051       {
76052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76053       };
76054     } catch (Dali::DaliException e) {
76055       {
76056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76057       };
76058     } catch (...) {
76059       {
76060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76061       };
76062     }
76063   }
76064
76065 }
76066
76067
76068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
76069   void * jresult ;
76070   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76071   Dali::Vector3 result;
76072
76073   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76074   {
76075     try {
76076       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
76077     } catch (std::out_of_range& e) {
76078       {
76079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76080       };
76081     } catch (std::exception& e) {
76082       {
76083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76084       };
76085     } catch (Dali::DaliException e) {
76086       {
76087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76088       };
76089     } catch (...) {
76090       {
76091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76092       };
76093     }
76094   }
76095
76096   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76097   return jresult;
76098 }
76099
76100
76101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
76102   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76103   Dali::Vector3 *arg2 = 0 ;
76104
76105   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76106   arg2 = (Dali::Vector3 *)jarg2;
76107   if (!arg2) {
76108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76109     return ;
76110   }
76111   {
76112     try {
76113       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
76114     } catch (std::out_of_range& e) {
76115       {
76116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76117       };
76118     } catch (std::exception& e) {
76119       {
76120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76121       };
76122     } catch (Dali::DaliException e) {
76123       {
76124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76125       };
76126     } catch (...) {
76127       {
76128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76129       };
76130     }
76131   }
76132
76133 }
76134
76135
76136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
76137   void * jresult ;
76138   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76139   Dali::Vector3 result;
76140
76141   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76142   {
76143     try {
76144       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
76145     } catch (std::out_of_range& e) {
76146       {
76147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76148       };
76149     } catch (std::exception& e) {
76150       {
76151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76152       };
76153     } catch (Dali::DaliException e) {
76154       {
76155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76156       };
76157     } catch (...) {
76158       {
76159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76160       };
76161     }
76162   }
76163
76164   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76165   return jresult;
76166 }
76167
76168
76169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
76170   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76171   Dali::Toolkit::ItemRange *arg2 = 0 ;
76172
76173   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76174   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
76175   if (!arg2) {
76176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
76177     return ;
76178   }
76179   {
76180     try {
76181       (arg1)->GetItemsRange(*arg2);
76182     } catch (std::out_of_range& e) {
76183       {
76184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76185       };
76186     } catch (std::exception& e) {
76187       {
76188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76189       };
76190     } catch (Dali::DaliException e) {
76191       {
76192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76193       };
76194     } catch (...) {
76195       {
76196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76197       };
76198     }
76199   }
76200
76201 }
76202
76203
76204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
76205   void * jresult ;
76206   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76207   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
76208
76209   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76210   {
76211     try {
76212       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
76213     } catch (std::out_of_range& e) {
76214       {
76215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76216       };
76217     } catch (std::exception& e) {
76218       {
76219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76220       };
76221     } catch (Dali::DaliException e) {
76222       {
76223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76224       };
76225     } catch (...) {
76226       {
76227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76228       };
76229     }
76230   }
76231
76232   jresult = (void *)result;
76233   return jresult;
76234 }
76235
76236
76237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
76238   Dali::Vector3 *arg1 = 0 ;
76239   PropertyInputContainer *arg2 = 0 ;
76240
76241   arg1 = (Dali::Vector3 *)jarg1;
76242   if (!arg1) {
76243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
76244     return ;
76245   }
76246   arg2 = (PropertyInputContainer *)jarg2;
76247   if (!arg2) {
76248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
76249     return ;
76250   }
76251   {
76252     try {
76253       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
76254     } catch (std::out_of_range& e) {
76255       {
76256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76257       };
76258     } catch (std::exception& e) {
76259       {
76260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76261       };
76262     } catch (Dali::DaliException e) {
76263       {
76264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76265       };
76266     } catch (...) {
76267       {
76268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76269       };
76270     }
76271   }
76272
76273 }
76274
76275
76276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
76277   Dali::Vector3 *arg1 = 0 ;
76278   PropertyInputContainer *arg2 = 0 ;
76279
76280   arg1 = (Dali::Vector3 *)jarg1;
76281   if (!arg1) {
76282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
76283     return ;
76284   }
76285   arg2 = (PropertyInputContainer *)jarg2;
76286   if (!arg2) {
76287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
76288     return ;
76289   }
76290   {
76291     try {
76292       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
76293     } catch (std::out_of_range& e) {
76294       {
76295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76296       };
76297     } catch (std::exception& e) {
76298       {
76299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76300       };
76301     } catch (Dali::DaliException e) {
76302       {
76303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76304       };
76305     } catch (...) {
76306       {
76307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76308       };
76309     }
76310   }
76311
76312 }
76313
76314
76315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
76316   void * jresult ;
76317   Dali::Toolkit::ScrollViewEffect *result = 0 ;
76318
76319   {
76320     try {
76321       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
76322     } catch (std::out_of_range& e) {
76323       {
76324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76325       };
76326     } catch (std::exception& e) {
76327       {
76328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76329       };
76330     } catch (Dali::DaliException e) {
76331       {
76332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76333       };
76334     } catch (...) {
76335       {
76336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76337       };
76338     }
76339   }
76340
76341   jresult = (void *)result;
76342   return jresult;
76343 }
76344
76345
76346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
76347   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
76348
76349   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
76350   {
76351     try {
76352       delete arg1;
76353     } catch (std::out_of_range& e) {
76354       {
76355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76356       };
76357     } catch (std::exception& e) {
76358       {
76359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76360       };
76361     } catch (Dali::DaliException e) {
76362       {
76363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76364       };
76365     } catch (...) {
76366       {
76367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76368       };
76369     }
76370   }
76371
76372 }
76373
76374
76375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
76376   void * jresult ;
76377   Dali::Path arg1 ;
76378   Dali::Vector3 *arg2 = 0 ;
76379   Dali::Property::Index arg3 ;
76380   Dali::Vector3 *arg4 = 0 ;
76381   unsigned int arg5 ;
76382   Dali::Path *argp1 ;
76383   Dali::Toolkit::ScrollViewPagePathEffect result;
76384
76385   argp1 = (Dali::Path *)jarg1;
76386   if (!argp1) {
76387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
76388     return 0;
76389   }
76390   arg1 = *argp1;
76391   arg2 = (Dali::Vector3 *)jarg2;
76392   if (!arg2) {
76393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76394     return 0;
76395   }
76396   arg3 = (Dali::Property::Index)jarg3;
76397   arg4 = (Dali::Vector3 *)jarg4;
76398   if (!arg4) {
76399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76400     return 0;
76401   }
76402   arg5 = (unsigned int)jarg5;
76403   {
76404     try {
76405       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
76406     } catch (std::out_of_range& e) {
76407       {
76408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76409       };
76410     } catch (std::exception& e) {
76411       {
76412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76413       };
76414     } catch (Dali::DaliException e) {
76415       {
76416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76417       };
76418     } catch (...) {
76419       {
76420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76421       };
76422     }
76423   }
76424
76425   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
76426   return jresult;
76427 }
76428
76429
76430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
76431   void * jresult ;
76432   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
76433
76434   {
76435     try {
76436       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
76437     } catch (std::out_of_range& e) {
76438       {
76439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76440       };
76441     } catch (std::exception& e) {
76442       {
76443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76444       };
76445     } catch (Dali::DaliException e) {
76446       {
76447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76448       };
76449     } catch (...) {
76450       {
76451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76452       };
76453     }
76454   }
76455
76456   jresult = (void *)result;
76457   return jresult;
76458 }
76459
76460
76461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
76462   void * jresult ;
76463   Dali::BaseHandle arg1 ;
76464   Dali::BaseHandle *argp1 ;
76465   Dali::Toolkit::ScrollViewPagePathEffect result;
76466
76467   argp1 = (Dali::BaseHandle *)jarg1;
76468   if (!argp1) {
76469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76470     return 0;
76471   }
76472   arg1 = *argp1;
76473   {
76474     try {
76475       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
76476     } catch (std::out_of_range& e) {
76477       {
76478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76479       };
76480     } catch (std::exception& e) {
76481       {
76482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76483       };
76484     } catch (Dali::DaliException e) {
76485       {
76486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76487       };
76488     } catch (...) {
76489       {
76490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76491       };
76492     }
76493   }
76494
76495   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
76496   return jresult;
76497 }
76498
76499
76500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
76501   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
76502   Dali::Actor arg2 ;
76503   unsigned int arg3 ;
76504   Dali::Actor *argp2 ;
76505
76506   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
76507   argp2 = (Dali::Actor *)jarg2;
76508   if (!argp2) {
76509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76510     return ;
76511   }
76512   arg2 = *argp2;
76513   arg3 = (unsigned int)jarg3;
76514   {
76515     try {
76516       (arg1)->ApplyToPage(arg2,arg3);
76517     } catch (std::out_of_range& e) {
76518       {
76519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76520       };
76521     } catch (std::exception& e) {
76522       {
76523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76524       };
76525     } catch (Dali::DaliException e) {
76526       {
76527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76528       };
76529     } catch (...) {
76530       {
76531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76532       };
76533     }
76534   }
76535
76536 }
76537
76538
76539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
76540   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
76541
76542   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
76543   {
76544     try {
76545       delete arg1;
76546     } catch (std::out_of_range& e) {
76547       {
76548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76549       };
76550     } catch (std::exception& e) {
76551       {
76552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76553       };
76554     } catch (Dali::DaliException e) {
76555       {
76556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76557       };
76558     } catch (...) {
76559       {
76560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76561       };
76562     }
76563   }
76564
76565 }
76566
76567
76568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
76569   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76570   Dali::Toolkit::ClampState arg2 ;
76571
76572   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76573   arg2 = (Dali::Toolkit::ClampState)jarg2;
76574   if (arg1) (arg1)->x = arg2;
76575 }
76576
76577
76578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
76579   int jresult ;
76580   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76581   Dali::Toolkit::ClampState result;
76582
76583   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76584   result = (Dali::Toolkit::ClampState) ((arg1)->x);
76585   jresult = (int)result;
76586   return jresult;
76587 }
76588
76589
76590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
76591   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76592   Dali::Toolkit::ClampState arg2 ;
76593
76594   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76595   arg2 = (Dali::Toolkit::ClampState)jarg2;
76596   if (arg1) (arg1)->y = arg2;
76597 }
76598
76599
76600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
76601   int jresult ;
76602   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76603   Dali::Toolkit::ClampState result;
76604
76605   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76606   result = (Dali::Toolkit::ClampState) ((arg1)->y);
76607   jresult = (int)result;
76608   return jresult;
76609 }
76610
76611
76612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
76613   void * jresult ;
76614   Dali::Toolkit::ClampState2D *result = 0 ;
76615
76616   {
76617     try {
76618       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
76619     } catch (std::out_of_range& e) {
76620       {
76621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76622       };
76623     } catch (std::exception& e) {
76624       {
76625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76626       };
76627     } catch (Dali::DaliException e) {
76628       {
76629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76630       };
76631     } catch (...) {
76632       {
76633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76634       };
76635     }
76636   }
76637
76638   jresult = (void *)result;
76639   return jresult;
76640 }
76641
76642
76643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
76644   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76645
76646   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76647   {
76648     try {
76649       delete arg1;
76650     } catch (std::out_of_range& e) {
76651       {
76652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76653       };
76654     } catch (std::exception& e) {
76655       {
76656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76657       };
76658     } catch (Dali::DaliException e) {
76659       {
76660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76661       };
76662     } catch (...) {
76663       {
76664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76665       };
76666     }
76667   }
76668
76669 }
76670
76671
76672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
76673   void * jresult ;
76674   float arg1 ;
76675   float arg2 ;
76676   bool arg3 ;
76677   Dali::Toolkit::RulerDomain *result = 0 ;
76678
76679   arg1 = (float)jarg1;
76680   arg2 = (float)jarg2;
76681   arg3 = jarg3 ? true : false;
76682   {
76683     try {
76684       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
76685     } catch (std::out_of_range& e) {
76686       {
76687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76688       };
76689     } catch (std::exception& e) {
76690       {
76691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76692       };
76693     } catch (Dali::DaliException e) {
76694       {
76695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76696       };
76697     } catch (...) {
76698       {
76699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76700       };
76701     }
76702   }
76703
76704   jresult = (void *)result;
76705   return jresult;
76706 }
76707
76708
76709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
76710   void * jresult ;
76711   float arg1 ;
76712   float arg2 ;
76713   Dali::Toolkit::RulerDomain *result = 0 ;
76714
76715   arg1 = (float)jarg1;
76716   arg2 = (float)jarg2;
76717   {
76718     try {
76719       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
76720     } catch (std::out_of_range& e) {
76721       {
76722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76723       };
76724     } catch (std::exception& e) {
76725       {
76726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76727       };
76728     } catch (Dali::DaliException e) {
76729       {
76730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76731       };
76732     } catch (...) {
76733       {
76734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76735       };
76736     }
76737   }
76738
76739   jresult = (void *)result;
76740   return jresult;
76741 }
76742
76743
76744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
76745   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76746   float arg2 ;
76747
76748   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76749   arg2 = (float)jarg2;
76750   if (arg1) (arg1)->min = arg2;
76751 }
76752
76753
76754 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
76755   float jresult ;
76756   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76757   float result;
76758
76759   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76760   result = (float) ((arg1)->min);
76761   jresult = result;
76762   return jresult;
76763 }
76764
76765
76766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
76767   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76768   float arg2 ;
76769
76770   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76771   arg2 = (float)jarg2;
76772   if (arg1) (arg1)->max = arg2;
76773 }
76774
76775
76776 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
76777   float jresult ;
76778   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76779   float result;
76780
76781   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76782   result = (float) ((arg1)->max);
76783   jresult = result;
76784   return jresult;
76785 }
76786
76787
76788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
76789   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76790   bool arg2 ;
76791
76792   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76793   arg2 = jarg2 ? true : false;
76794   if (arg1) (arg1)->enabled = arg2;
76795 }
76796
76797
76798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
76799   unsigned int jresult ;
76800   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76801   bool result;
76802
76803   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76804   result = (bool) ((arg1)->enabled);
76805   jresult = result;
76806   return jresult;
76807 }
76808
76809
76810 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
76811   float jresult ;
76812   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76813   float arg2 ;
76814   float arg3 ;
76815   float arg4 ;
76816   float result;
76817
76818   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76819   arg2 = (float)jarg2;
76820   arg3 = (float)jarg3;
76821   arg4 = (float)jarg4;
76822   {
76823     try {
76824       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
76825     } catch (std::out_of_range& e) {
76826       {
76827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76828       };
76829     } catch (std::exception& e) {
76830       {
76831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76832       };
76833     } catch (Dali::DaliException e) {
76834       {
76835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76836       };
76837     } catch (...) {
76838       {
76839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76840       };
76841     }
76842   }
76843
76844   jresult = result;
76845   return jresult;
76846 }
76847
76848
76849 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
76850   float jresult ;
76851   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76852   float arg2 ;
76853   float arg3 ;
76854   float result;
76855
76856   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76857   arg2 = (float)jarg2;
76858   arg3 = (float)jarg3;
76859   {
76860     try {
76861       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
76862     } catch (std::out_of_range& e) {
76863       {
76864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76865       };
76866     } catch (std::exception& e) {
76867       {
76868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76869       };
76870     } catch (Dali::DaliException e) {
76871       {
76872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76873       };
76874     } catch (...) {
76875       {
76876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76877       };
76878     }
76879   }
76880
76881   jresult = result;
76882   return jresult;
76883 }
76884
76885
76886 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
76887   float jresult ;
76888   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76889   float arg2 ;
76890   float result;
76891
76892   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76893   arg2 = (float)jarg2;
76894   {
76895     try {
76896       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
76897     } catch (std::out_of_range& e) {
76898       {
76899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76900       };
76901     } catch (std::exception& e) {
76902       {
76903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76904       };
76905     } catch (Dali::DaliException e) {
76906       {
76907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76908       };
76909     } catch (...) {
76910       {
76911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76912       };
76913     }
76914   }
76915
76916   jresult = result;
76917   return jresult;
76918 }
76919
76920
76921 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
76922   float jresult ;
76923   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76924   float arg2 ;
76925   float arg3 ;
76926   float arg4 ;
76927   Dali::Toolkit::ClampState *arg5 = 0 ;
76928   float result;
76929
76930   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76931   arg2 = (float)jarg2;
76932   arg3 = (float)jarg3;
76933   arg4 = (float)jarg4;
76934   arg5 = (Dali::Toolkit::ClampState *)jarg5;
76935   if (!arg5) {
76936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
76937     return 0;
76938   }
76939   {
76940     try {
76941       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
76942     } catch (std::out_of_range& e) {
76943       {
76944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76945       };
76946     } catch (std::exception& e) {
76947       {
76948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76949       };
76950     } catch (Dali::DaliException e) {
76951       {
76952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76953       };
76954     } catch (...) {
76955       {
76956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76957       };
76958     }
76959   }
76960
76961   jresult = result;
76962   return jresult;
76963 }
76964
76965
76966 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
76967   float jresult ;
76968   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76969   float result;
76970
76971   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76972   {
76973     try {
76974       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
76975     } catch (std::out_of_range& e) {
76976       {
76977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76978       };
76979     } catch (std::exception& e) {
76980       {
76981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76982       };
76983     } catch (Dali::DaliException e) {
76984       {
76985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76986       };
76987     } catch (...) {
76988       {
76989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76990       };
76991     }
76992   }
76993
76994   jresult = result;
76995   return jresult;
76996 }
76997
76998
76999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
77000   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77001
77002   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77003   {
77004     try {
77005       delete arg1;
77006     } catch (std::out_of_range& e) {
77007       {
77008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77009       };
77010     } catch (std::exception& e) {
77011       {
77012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77013       };
77014     } catch (Dali::DaliException e) {
77015       {
77016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77017       };
77018     } catch (...) {
77019       {
77020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77021       };
77022     }
77023   }
77024
77025 }
77026
77027
77028 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
77029   float jresult ;
77030   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77031   float arg2 ;
77032   float arg3 ;
77033   float result;
77034
77035   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77036   arg2 = (float)jarg2;
77037   arg3 = (float)jarg3;
77038   {
77039     try {
77040       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
77041     } catch (std::out_of_range& e) {
77042       {
77043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77044       };
77045     } catch (std::exception& e) {
77046       {
77047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77048       };
77049     } catch (Dali::DaliException e) {
77050       {
77051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77052       };
77053     } catch (...) {
77054       {
77055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77056       };
77057     }
77058   }
77059
77060   jresult = result;
77061   return jresult;
77062 }
77063
77064
77065 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
77066   float jresult ;
77067   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77068   float arg2 ;
77069   float result;
77070
77071   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77072   arg2 = (float)jarg2;
77073   {
77074     try {
77075       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
77076     } catch (std::out_of_range& e) {
77077       {
77078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77079       };
77080     } catch (std::exception& e) {
77081       {
77082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77083       };
77084     } catch (Dali::DaliException e) {
77085       {
77086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77087       };
77088     } catch (...) {
77089       {
77090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77091       };
77092     }
77093   }
77094
77095   jresult = result;
77096   return jresult;
77097 }
77098
77099
77100 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
77101   float jresult ;
77102   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77103   unsigned int arg2 ;
77104   unsigned int *arg3 = 0 ;
77105   bool arg4 ;
77106   float result;
77107
77108   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77109   arg2 = (unsigned int)jarg2;
77110   arg3 = (unsigned int *)jarg3;
77111   arg4 = jarg4 ? true : false;
77112   {
77113     try {
77114       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
77115     } catch (std::out_of_range& e) {
77116       {
77117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77118       };
77119     } catch (std::exception& e) {
77120       {
77121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77122       };
77123     } catch (Dali::DaliException e) {
77124       {
77125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77126       };
77127     } catch (...) {
77128       {
77129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77130       };
77131     }
77132   }
77133
77134   jresult = result;
77135   return jresult;
77136 }
77137
77138
77139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
77140   unsigned int jresult ;
77141   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77142   float arg2 ;
77143   bool arg3 ;
77144   unsigned int result;
77145
77146   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77147   arg2 = (float)jarg2;
77148   arg3 = jarg3 ? true : false;
77149   {
77150     try {
77151       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
77152     } catch (std::out_of_range& e) {
77153       {
77154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77155       };
77156     } catch (std::exception& e) {
77157       {
77158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77159       };
77160     } catch (Dali::DaliException e) {
77161       {
77162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77163       };
77164     } catch (...) {
77165       {
77166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77167       };
77168     }
77169   }
77170
77171   jresult = result;
77172   return jresult;
77173 }
77174
77175
77176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
77177   unsigned int jresult ;
77178   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77179   unsigned int result;
77180
77181   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77182   {
77183     try {
77184       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
77185     } catch (std::out_of_range& e) {
77186       {
77187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77188       };
77189     } catch (std::exception& e) {
77190       {
77191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77192       };
77193     } catch (Dali::DaliException e) {
77194       {
77195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77196       };
77197     } catch (...) {
77198       {
77199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77200       };
77201     }
77202   }
77203
77204   jresult = result;
77205   return jresult;
77206 }
77207
77208
77209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
77210   int jresult ;
77211   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77212   Dali::Toolkit::Ruler::RulerType result;
77213
77214   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77215   {
77216     try {
77217       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
77218     } catch (std::out_of_range& e) {
77219       {
77220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77221       };
77222     } catch (std::exception& e) {
77223       {
77224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77225       };
77226     } catch (Dali::DaliException e) {
77227       {
77228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77229       };
77230     } catch (...) {
77231       {
77232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77233       };
77234     }
77235   }
77236
77237   jresult = (int)result;
77238   return jresult;
77239 }
77240
77241
77242 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
77243   unsigned int jresult ;
77244   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77245   bool result;
77246
77247   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77248   {
77249     try {
77250       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
77251     } catch (std::out_of_range& e) {
77252       {
77253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77254       };
77255     } catch (std::exception& e) {
77256       {
77257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77258       };
77259     } catch (Dali::DaliException e) {
77260       {
77261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77262       };
77263     } catch (...) {
77264       {
77265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77266       };
77267     }
77268   }
77269
77270   jresult = result;
77271   return jresult;
77272 }
77273
77274
77275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
77276   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77277
77278   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77279   {
77280     try {
77281       (arg1)->Enable();
77282     } catch (std::out_of_range& e) {
77283       {
77284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77285       };
77286     } catch (std::exception& e) {
77287       {
77288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77289       };
77290     } catch (Dali::DaliException e) {
77291       {
77292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77293       };
77294     } catch (...) {
77295       {
77296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77297       };
77298     }
77299   }
77300
77301 }
77302
77303
77304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
77305   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77306
77307   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77308   {
77309     try {
77310       (arg1)->Disable();
77311     } catch (std::out_of_range& e) {
77312       {
77313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77314       };
77315     } catch (std::exception& e) {
77316       {
77317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77318       };
77319     } catch (Dali::DaliException e) {
77320       {
77321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77322       };
77323     } catch (...) {
77324       {
77325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77326       };
77327     }
77328   }
77329
77330 }
77331
77332
77333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
77334   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77335   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
77336   Dali::Toolkit::RulerDomain *argp2 ;
77337
77338   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77339   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
77340   if (!argp2) {
77341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
77342     return ;
77343   }
77344   arg2 = *argp2;
77345   {
77346     try {
77347       (arg1)->SetDomain(arg2);
77348     } catch (std::out_of_range& e) {
77349       {
77350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77351       };
77352     } catch (std::exception& e) {
77353       {
77354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77355       };
77356     } catch (Dali::DaliException e) {
77357       {
77358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77359       };
77360     } catch (...) {
77361       {
77362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77363       };
77364     }
77365   }
77366
77367 }
77368
77369
77370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
77371   void * jresult ;
77372   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77373   Dali::Toolkit::RulerDomain *result = 0 ;
77374
77375   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77376   {
77377     try {
77378       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
77379     } catch (std::out_of_range& e) {
77380       {
77381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77382       };
77383     } catch (std::exception& e) {
77384       {
77385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77386       };
77387     } catch (Dali::DaliException e) {
77388       {
77389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77390       };
77391     } catch (...) {
77392       {
77393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77394       };
77395     }
77396   }
77397
77398   jresult = (void *)result;
77399   return jresult;
77400 }
77401
77402
77403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
77404   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77405
77406   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77407   {
77408     try {
77409       (arg1)->DisableDomain();
77410     } catch (std::out_of_range& e) {
77411       {
77412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77413       };
77414     } catch (std::exception& e) {
77415       {
77416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77417       };
77418     } catch (Dali::DaliException e) {
77419       {
77420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77421       };
77422     } catch (...) {
77423       {
77424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77425       };
77426     }
77427   }
77428
77429 }
77430
77431
77432 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
77433   float jresult ;
77434   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77435   float arg2 ;
77436   float arg3 ;
77437   float arg4 ;
77438   float result;
77439
77440   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77441   arg2 = (float)jarg2;
77442   arg3 = (float)jarg3;
77443   arg4 = (float)jarg4;
77444   {
77445     try {
77446       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
77447     } catch (std::out_of_range& e) {
77448       {
77449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77450       };
77451     } catch (std::exception& e) {
77452       {
77453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77454       };
77455     } catch (Dali::DaliException e) {
77456       {
77457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77458       };
77459     } catch (...) {
77460       {
77461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77462       };
77463     }
77464   }
77465
77466   jresult = result;
77467   return jresult;
77468 }
77469
77470
77471 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
77472   float jresult ;
77473   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77474   float arg2 ;
77475   float arg3 ;
77476   float result;
77477
77478   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77479   arg2 = (float)jarg2;
77480   arg3 = (float)jarg3;
77481   {
77482     try {
77483       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
77484     } catch (std::out_of_range& e) {
77485       {
77486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77487       };
77488     } catch (std::exception& e) {
77489       {
77490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77491       };
77492     } catch (Dali::DaliException e) {
77493       {
77494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77495       };
77496     } catch (...) {
77497       {
77498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77499       };
77500     }
77501   }
77502
77503   jresult = result;
77504   return jresult;
77505 }
77506
77507
77508 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
77509   float jresult ;
77510   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77511   float arg2 ;
77512   float result;
77513
77514   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77515   arg2 = (float)jarg2;
77516   {
77517     try {
77518       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
77519     } catch (std::out_of_range& e) {
77520       {
77521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77522       };
77523     } catch (std::exception& e) {
77524       {
77525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77526       };
77527     } catch (Dali::DaliException e) {
77528       {
77529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77530       };
77531     } catch (...) {
77532       {
77533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77534       };
77535     }
77536   }
77537
77538   jresult = result;
77539   return jresult;
77540 }
77541
77542
77543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
77544   float jresult ;
77545   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77546   float arg2 ;
77547   float arg3 ;
77548   float arg4 ;
77549   Dali::Toolkit::ClampState *arg5 = 0 ;
77550   float result;
77551
77552   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77553   arg2 = (float)jarg2;
77554   arg3 = (float)jarg3;
77555   arg4 = (float)jarg4;
77556   arg5 = (Dali::Toolkit::ClampState *)jarg5;
77557   if (!arg5) {
77558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77559     return 0;
77560   }
77561   {
77562     try {
77563       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
77564     } catch (std::out_of_range& e) {
77565       {
77566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77567       };
77568     } catch (std::exception& e) {
77569       {
77570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77571       };
77572     } catch (Dali::DaliException e) {
77573       {
77574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77575       };
77576     } catch (...) {
77577       {
77578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77579       };
77580     }
77581   }
77582
77583   jresult = result;
77584   return jresult;
77585 }
77586
77587
77588 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
77589   float jresult ;
77590   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77591   float arg2 ;
77592   float arg3 ;
77593   float arg4 ;
77594   float arg5 ;
77595   float result;
77596
77597   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77598   arg2 = (float)jarg2;
77599   arg3 = (float)jarg3;
77600   arg4 = (float)jarg4;
77601   arg5 = (float)jarg5;
77602   {
77603     try {
77604       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
77605     } catch (std::out_of_range& e) {
77606       {
77607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77608       };
77609     } catch (std::exception& e) {
77610       {
77611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77612       };
77613     } catch (Dali::DaliException e) {
77614       {
77615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77616       };
77617     } catch (...) {
77618       {
77619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77620       };
77621     }
77622   }
77623
77624   jresult = result;
77625   return jresult;
77626 }
77627
77628
77629 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
77630   float jresult ;
77631   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77632   float arg2 ;
77633   float arg3 ;
77634   float arg4 ;
77635   float result;
77636
77637   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77638   arg2 = (float)jarg2;
77639   arg3 = (float)jarg3;
77640   arg4 = (float)jarg4;
77641   {
77642     try {
77643       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
77644     } catch (std::out_of_range& e) {
77645       {
77646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77647       };
77648     } catch (std::exception& e) {
77649       {
77650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77651       };
77652     } catch (Dali::DaliException e) {
77653       {
77654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77655       };
77656     } catch (...) {
77657       {
77658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77659       };
77660     }
77661   }
77662
77663   jresult = result;
77664   return jresult;
77665 }
77666
77667
77668 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
77669   float jresult ;
77670   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77671   float arg2 ;
77672   float arg3 ;
77673   float result;
77674
77675   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77676   arg2 = (float)jarg2;
77677   arg3 = (float)jarg3;
77678   {
77679     try {
77680       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
77681     } catch (std::out_of_range& e) {
77682       {
77683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77684       };
77685     } catch (std::exception& e) {
77686       {
77687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77688       };
77689     } catch (Dali::DaliException e) {
77690       {
77691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77692       };
77693     } catch (...) {
77694       {
77695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77696       };
77697     }
77698   }
77699
77700   jresult = result;
77701   return jresult;
77702 }
77703
77704
77705 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
77706   float jresult ;
77707   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77708   float arg2 ;
77709   float result;
77710
77711   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77712   arg2 = (float)jarg2;
77713   {
77714     try {
77715       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
77716     } catch (std::out_of_range& e) {
77717       {
77718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77719       };
77720     } catch (std::exception& e) {
77721       {
77722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77723       };
77724     } catch (Dali::DaliException e) {
77725       {
77726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77727       };
77728     } catch (...) {
77729       {
77730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77731       };
77732     }
77733   }
77734
77735   jresult = result;
77736   return jresult;
77737 }
77738
77739
77740 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
77741   float jresult ;
77742   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77743   float arg2 ;
77744   float arg3 ;
77745   float arg4 ;
77746   float arg5 ;
77747   Dali::Toolkit::ClampState *arg6 = 0 ;
77748   float result;
77749
77750   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77751   arg2 = (float)jarg2;
77752   arg3 = (float)jarg3;
77753   arg4 = (float)jarg4;
77754   arg5 = (float)jarg5;
77755   arg6 = (Dali::Toolkit::ClampState *)jarg6;
77756   if (!arg6) {
77757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77758     return 0;
77759   }
77760   {
77761     try {
77762       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
77763     } catch (std::out_of_range& e) {
77764       {
77765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77766       };
77767     } catch (std::exception& e) {
77768       {
77769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77770       };
77771     } catch (Dali::DaliException e) {
77772       {
77773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77774       };
77775     } catch (...) {
77776       {
77777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77778       };
77779     }
77780   }
77781
77782   jresult = result;
77783   return jresult;
77784 }
77785
77786
77787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
77788   void * jresult ;
77789   Dali::Toolkit::DefaultRuler *result = 0 ;
77790
77791   {
77792     try {
77793       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
77794     } catch (std::out_of_range& e) {
77795       {
77796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77797       };
77798     } catch (std::exception& e) {
77799       {
77800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77801       };
77802     } catch (Dali::DaliException e) {
77803       {
77804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77805       };
77806     } catch (...) {
77807       {
77808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77809       };
77810     }
77811   }
77812
77813   jresult = (void *)result;
77814   return jresult;
77815 }
77816
77817
77818 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
77819   float jresult ;
77820   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77821   float arg2 ;
77822   float arg3 ;
77823   float result;
77824
77825   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77826   arg2 = (float)jarg2;
77827   arg3 = (float)jarg3;
77828   {
77829     try {
77830       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
77831     } catch (std::out_of_range& e) {
77832       {
77833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77834       };
77835     } catch (std::exception& e) {
77836       {
77837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77838       };
77839     } catch (Dali::DaliException e) {
77840       {
77841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77842       };
77843     } catch (...) {
77844       {
77845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77846       };
77847     }
77848   }
77849
77850   jresult = result;
77851   return jresult;
77852 }
77853
77854
77855 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
77856   float jresult ;
77857   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77858   unsigned int arg2 ;
77859   unsigned int *arg3 = 0 ;
77860   bool arg4 ;
77861   float result;
77862
77863   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77864   arg2 = (unsigned int)jarg2;
77865   arg3 = (unsigned int *)jarg3;
77866   arg4 = jarg4 ? true : false;
77867   {
77868     try {
77869       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
77870     } catch (std::out_of_range& e) {
77871       {
77872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77873       };
77874     } catch (std::exception& e) {
77875       {
77876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77877       };
77878     } catch (Dali::DaliException e) {
77879       {
77880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77881       };
77882     } catch (...) {
77883       {
77884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77885       };
77886     }
77887   }
77888
77889   jresult = result;
77890   return jresult;
77891 }
77892
77893
77894 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
77895   unsigned int jresult ;
77896   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77897   float arg2 ;
77898   bool arg3 ;
77899   unsigned int result;
77900
77901   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77902   arg2 = (float)jarg2;
77903   arg3 = jarg3 ? true : false;
77904   {
77905     try {
77906       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
77907     } catch (std::out_of_range& e) {
77908       {
77909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77910       };
77911     } catch (std::exception& e) {
77912       {
77913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77914       };
77915     } catch (Dali::DaliException e) {
77916       {
77917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77918       };
77919     } catch (...) {
77920       {
77921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77922       };
77923     }
77924   }
77925
77926   jresult = result;
77927   return jresult;
77928 }
77929
77930
77931 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
77932   unsigned int jresult ;
77933   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77934   unsigned int result;
77935
77936   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77937   {
77938     try {
77939       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
77940     } catch (std::out_of_range& e) {
77941       {
77942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77943       };
77944     } catch (std::exception& e) {
77945       {
77946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77947       };
77948     } catch (Dali::DaliException e) {
77949       {
77950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77951       };
77952     } catch (...) {
77953       {
77954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77955       };
77956     }
77957   }
77958
77959   jresult = result;
77960   return jresult;
77961 }
77962
77963
77964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
77965   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77966
77967   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77968   {
77969     try {
77970       delete arg1;
77971     } catch (std::out_of_range& e) {
77972       {
77973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77974       };
77975     } catch (std::exception& e) {
77976       {
77977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77978       };
77979     } catch (Dali::DaliException e) {
77980       {
77981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77982       };
77983     } catch (...) {
77984       {
77985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77986       };
77987     }
77988   }
77989
77990 }
77991
77992
77993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
77994   void * jresult ;
77995   float arg1 ;
77996   Dali::Toolkit::FixedRuler *result = 0 ;
77997
77998   arg1 = (float)jarg1;
77999   {
78000     try {
78001       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
78002     } catch (std::out_of_range& e) {
78003       {
78004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78005       };
78006     } catch (std::exception& e) {
78007       {
78008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78009       };
78010     } catch (Dali::DaliException e) {
78011       {
78012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78013       };
78014     } catch (...) {
78015       {
78016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78017       };
78018     }
78019   }
78020
78021   jresult = (void *)result;
78022   return jresult;
78023 }
78024
78025
78026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
78027   void * jresult ;
78028   Dali::Toolkit::FixedRuler *result = 0 ;
78029
78030   {
78031     try {
78032       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
78033     } catch (std::out_of_range& e) {
78034       {
78035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78036       };
78037     } catch (std::exception& e) {
78038       {
78039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78040       };
78041     } catch (Dali::DaliException e) {
78042       {
78043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78044       };
78045     } catch (...) {
78046       {
78047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78048       };
78049     }
78050   }
78051
78052   jresult = (void *)result;
78053   return jresult;
78054 }
78055
78056
78057 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78058   float jresult ;
78059   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78060   float arg2 ;
78061   float arg3 ;
78062   float result;
78063
78064   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78065   arg2 = (float)jarg2;
78066   arg3 = (float)jarg3;
78067   {
78068     try {
78069       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
78070     } catch (std::out_of_range& e) {
78071       {
78072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78073       };
78074     } catch (std::exception& e) {
78075       {
78076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78077       };
78078     } catch (Dali::DaliException e) {
78079       {
78080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78081       };
78082     } catch (...) {
78083       {
78084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78085       };
78086     }
78087   }
78088
78089   jresult = result;
78090   return jresult;
78091 }
78092
78093
78094 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78095   float jresult ;
78096   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78097   unsigned int arg2 ;
78098   unsigned int *arg3 = 0 ;
78099   bool arg4 ;
78100   float result;
78101
78102   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78103   arg2 = (unsigned int)jarg2;
78104   arg3 = (unsigned int *)jarg3;
78105   arg4 = jarg4 ? true : false;
78106   {
78107     try {
78108       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78109     } catch (std::out_of_range& e) {
78110       {
78111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78112       };
78113     } catch (std::exception& e) {
78114       {
78115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78116       };
78117     } catch (Dali::DaliException e) {
78118       {
78119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78120       };
78121     } catch (...) {
78122       {
78123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78124       };
78125     }
78126   }
78127
78128   jresult = result;
78129   return jresult;
78130 }
78131
78132
78133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78134   unsigned int jresult ;
78135   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78136   float arg2 ;
78137   bool arg3 ;
78138   unsigned int result;
78139
78140   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78141   arg2 = (float)jarg2;
78142   arg3 = jarg3 ? true : false;
78143   {
78144     try {
78145       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78146     } catch (std::out_of_range& e) {
78147       {
78148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78149       };
78150     } catch (std::exception& e) {
78151       {
78152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78153       };
78154     } catch (Dali::DaliException e) {
78155       {
78156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78157       };
78158     } catch (...) {
78159       {
78160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78161       };
78162     }
78163   }
78164
78165   jresult = result;
78166   return jresult;
78167 }
78168
78169
78170 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
78171   unsigned int jresult ;
78172   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78173   unsigned int result;
78174
78175   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78176   {
78177     try {
78178       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
78179     } catch (std::out_of_range& e) {
78180       {
78181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78182       };
78183     } catch (std::exception& e) {
78184       {
78185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78186       };
78187     } catch (Dali::DaliException e) {
78188       {
78189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78190       };
78191     } catch (...) {
78192       {
78193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78194       };
78195     }
78196   }
78197
78198   jresult = result;
78199   return jresult;
78200 }
78201
78202
78203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
78204   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78205
78206   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78207   {
78208     try {
78209       delete arg1;
78210     } catch (std::out_of_range& e) {
78211       {
78212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78213       };
78214     } catch (std::exception& e) {
78215       {
78216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78217       };
78218     } catch (Dali::DaliException e) {
78219       {
78220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78221       };
78222     } catch (...) {
78223       {
78224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78225       };
78226     }
78227   }
78228
78229 }
78230
78231
78232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
78233   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78234   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
78235
78236   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78237   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
78238   if (arg1) (arg1)->scale = *arg2;
78239 }
78240
78241
78242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
78243   void * jresult ;
78244   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78245   Dali::Toolkit::ClampState2D *result = 0 ;
78246
78247   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78248   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
78249   jresult = (void *)result;
78250   return jresult;
78251 }
78252
78253
78254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
78255   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78256   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
78257
78258   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78259   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
78260   if (arg1) (arg1)->position = *arg2;
78261 }
78262
78263
78264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
78265   void * jresult ;
78266   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78267   Dali::Toolkit::ClampState2D *result = 0 ;
78268
78269   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78270   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
78271   jresult = (void *)result;
78272   return jresult;
78273 }
78274
78275
78276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
78277   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78278   Dali::Toolkit::ClampState arg2 ;
78279
78280   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78281   arg2 = (Dali::Toolkit::ClampState)jarg2;
78282   if (arg1) (arg1)->rotation = arg2;
78283 }
78284
78285
78286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
78287   int jresult ;
78288   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78289   Dali::Toolkit::ClampState result;
78290
78291   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78292   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
78293   jresult = (int)result;
78294   return jresult;
78295 }
78296
78297
78298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
78299   void * jresult ;
78300   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
78301
78302   {
78303     try {
78304       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
78305     } catch (std::out_of_range& e) {
78306       {
78307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78308       };
78309     } catch (std::exception& e) {
78310       {
78311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78312       };
78313     } catch (Dali::DaliException e) {
78314       {
78315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78316       };
78317     } catch (...) {
78318       {
78319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78320       };
78321     }
78322   }
78323
78324   jresult = (void *)result;
78325   return jresult;
78326 }
78327
78328
78329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
78330   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78331
78332   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78333   {
78334     try {
78335       delete arg1;
78336     } catch (std::out_of_range& e) {
78337       {
78338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78339       };
78340     } catch (std::exception& e) {
78341       {
78342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78343       };
78344     } catch (Dali::DaliException e) {
78345       {
78346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78347       };
78348     } catch (...) {
78349       {
78350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78351       };
78352     }
78353   }
78354
78355 }
78356
78357
78358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
78359   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78360   Dali::Toolkit::SnapType arg2 ;
78361
78362   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78363   arg2 = (Dali::Toolkit::SnapType)jarg2;
78364   if (arg1) (arg1)->type = arg2;
78365 }
78366
78367
78368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
78369   int jresult ;
78370   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78371   Dali::Toolkit::SnapType result;
78372
78373   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78374   result = (Dali::Toolkit::SnapType) ((arg1)->type);
78375   jresult = (int)result;
78376   return jresult;
78377 }
78378
78379
78380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
78381   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78382   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
78383
78384   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78385   arg2 = (Dali::Vector2 *)jarg2;
78386   if (arg1) (arg1)->position = *arg2;
78387 }
78388
78389
78390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
78391   void * jresult ;
78392   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78393   Dali::Vector2 *result = 0 ;
78394
78395   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78396   result = (Dali::Vector2 *)& ((arg1)->position);
78397   jresult = (void *)result;
78398   return jresult;
78399 }
78400
78401
78402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
78403   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78404   float arg2 ;
78405
78406   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78407   arg2 = (float)jarg2;
78408   if (arg1) (arg1)->duration = arg2;
78409 }
78410
78411
78412 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
78413   float jresult ;
78414   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78415   float result;
78416
78417   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78418   result = (float) ((arg1)->duration);
78419   jresult = result;
78420   return jresult;
78421 }
78422
78423
78424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
78425   void * jresult ;
78426   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
78427
78428   {
78429     try {
78430       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
78431     } catch (std::out_of_range& e) {
78432       {
78433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78434       };
78435     } catch (std::exception& e) {
78436       {
78437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78438       };
78439     } catch (Dali::DaliException e) {
78440       {
78441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78442       };
78443     } catch (...) {
78444       {
78445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78446       };
78447     }
78448   }
78449
78450   jresult = (void *)result;
78451   return jresult;
78452 }
78453
78454
78455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
78456   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78457
78458   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78459   {
78460     try {
78461       delete arg1;
78462     } catch (std::out_of_range& e) {
78463       {
78464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78465       };
78466     } catch (std::exception& e) {
78467       {
78468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78469       };
78470     } catch (Dali::DaliException e) {
78471       {
78472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78473       };
78474     } catch (...) {
78475       {
78476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78477       };
78478     }
78479   }
78480
78481 }
78482
78483
78484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
78485   int jresult ;
78486   int result;
78487
78488   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
78489   jresult = (int)result;
78490   return jresult;
78491 }
78492
78493
78494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
78495   int jresult ;
78496   int result;
78497
78498   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
78499   jresult = (int)result;
78500   return jresult;
78501 }
78502
78503
78504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
78505   int jresult ;
78506   int result;
78507
78508   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
78509   jresult = (int)result;
78510   return jresult;
78511 }
78512
78513
78514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
78515   int jresult ;
78516   int result;
78517
78518   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
78519   jresult = (int)result;
78520   return jresult;
78521 }
78522
78523
78524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
78525   int jresult ;
78526   int result;
78527
78528   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
78529   jresult = (int)result;
78530   return jresult;
78531 }
78532
78533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
78534   int jresult ;
78535   int result;
78536
78537   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
78538   jresult = (int)result;
78539   return jresult;
78540 }
78541
78542
78543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
78544   int jresult ;
78545   int result;
78546
78547   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
78548   jresult = (int)result;
78549   return jresult;
78550 }
78551
78552
78553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
78554   int jresult ;
78555   int result;
78556
78557   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
78558   jresult = (int)result;
78559   return jresult;
78560 }
78561
78562
78563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
78564   int jresult ;
78565   int result;
78566
78567   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
78568   jresult = (int)result;
78569   return jresult;
78570 }
78571
78572
78573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
78574   int jresult ;
78575   int result;
78576
78577   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
78578   jresult = (int)result;
78579   return jresult;
78580 }
78581
78582
78583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
78584   int jresult ;
78585   int result;
78586
78587   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
78588   jresult = (int)result;
78589   return jresult;
78590 }
78591
78592
78593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
78594   int jresult ;
78595   int result;
78596
78597   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
78598   jresult = (int)result;
78599   return jresult;
78600 }
78601
78602
78603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
78604   int jresult ;
78605   int result;
78606
78607   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
78608   jresult = (int)result;
78609   return jresult;
78610 }
78611
78612
78613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
78614   int jresult ;
78615   int result;
78616
78617   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
78618   jresult = (int)result;
78619   return jresult;
78620 }
78621
78622
78623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
78624   int jresult ;
78625   int result;
78626
78627   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
78628   jresult = (int)result;
78629   return jresult;
78630 }
78631
78632
78633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
78634   int jresult ;
78635   int result;
78636
78637   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
78638   jresult = (int)result;
78639   return jresult;
78640 }
78641
78642
78643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
78644   int jresult ;
78645   int result;
78646
78647   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
78648   jresult = (int)result;
78649   return jresult;
78650 }
78651
78652
78653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
78654   int jresult ;
78655   int result;
78656
78657   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
78658   jresult = (int)result;
78659   return jresult;
78660 }
78661
78662
78663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
78664   int jresult ;
78665   int result;
78666
78667   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
78668   jresult = (int)result;
78669   return jresult;
78670 }
78671
78672
78673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
78674   int jresult ;
78675   int result;
78676
78677   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
78678   jresult = (int)result;
78679   return jresult;
78680 }
78681
78682
78683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
78684   int jresult ;
78685   int result;
78686
78687   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
78688   jresult = (int)result;
78689   return jresult;
78690 }
78691
78692
78693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
78694   int jresult ;
78695   int result;
78696
78697   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
78698   jresult = (int)result;
78699   return jresult;
78700 }
78701
78702
78703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
78704   int jresult ;
78705   int result;
78706
78707   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
78708   jresult = (int)result;
78709   return jresult;
78710 }
78711
78712
78713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
78714   int jresult ;
78715   int result;
78716
78717   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
78718   jresult = (int)result;
78719   return jresult;
78720 }
78721
78722
78723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
78724   int jresult ;
78725   int result;
78726
78727   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
78728   jresult = (int)result;
78729   return jresult;
78730 }
78731
78732
78733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
78734   int jresult ;
78735   int result;
78736
78737   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
78738   jresult = (int)result;
78739   return jresult;
78740 }
78741
78742
78743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
78744   void * jresult ;
78745   Dali::Toolkit::ScrollView::Property *result = 0 ;
78746
78747   {
78748     try {
78749       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
78750     } catch (std::out_of_range& e) {
78751       {
78752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78753       };
78754     } catch (std::exception& e) {
78755       {
78756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78757       };
78758     } catch (Dali::DaliException e) {
78759       {
78760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78761       };
78762     } catch (...) {
78763       {
78764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78765       };
78766     }
78767   }
78768
78769   jresult = (void *)result;
78770   return jresult;
78771 }
78772
78773
78774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
78775   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
78776
78777   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
78778   {
78779     try {
78780       delete arg1;
78781     } catch (std::out_of_range& e) {
78782       {
78783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78784       };
78785     } catch (std::exception& e) {
78786       {
78787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78788       };
78789     } catch (Dali::DaliException e) {
78790       {
78791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78792       };
78793     } catch (...) {
78794       {
78795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78796       };
78797     }
78798   }
78799
78800 }
78801
78802
78803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
78804   void * jresult ;
78805   Dali::Toolkit::ScrollView *result = 0 ;
78806
78807   {
78808     try {
78809       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
78810     } catch (std::out_of_range& e) {
78811       {
78812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78813       };
78814     } catch (std::exception& e) {
78815       {
78816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78817       };
78818     } catch (Dali::DaliException e) {
78819       {
78820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78821       };
78822     } catch (...) {
78823       {
78824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78825       };
78826     }
78827   }
78828
78829   jresult = (void *)result;
78830   return jresult;
78831 }
78832
78833
78834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
78835   void * jresult ;
78836   Dali::Toolkit::ScrollView *arg1 = 0 ;
78837   Dali::Toolkit::ScrollView *result = 0 ;
78838
78839   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78840   if (!arg1) {
78841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
78842     return 0;
78843   }
78844   {
78845     try {
78846       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
78847     } catch (std::out_of_range& e) {
78848       {
78849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78850       };
78851     } catch (std::exception& e) {
78852       {
78853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78854       };
78855     } catch (Dali::DaliException e) {
78856       {
78857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78858       };
78859     } catch (...) {
78860       {
78861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78862       };
78863     }
78864   }
78865
78866   jresult = (void *)result;
78867   return jresult;
78868 }
78869
78870
78871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
78872   void * jresult ;
78873   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78874   Dali::Toolkit::ScrollView *arg2 = 0 ;
78875   Dali::Toolkit::ScrollView *result = 0 ;
78876
78877   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78878   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
78879   if (!arg2) {
78880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
78881     return 0;
78882   }
78883   {
78884     try {
78885       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
78886     } catch (std::out_of_range& e) {
78887       {
78888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78889       };
78890     } catch (std::exception& e) {
78891       {
78892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78893       };
78894     } catch (Dali::DaliException e) {
78895       {
78896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78897       };
78898     } catch (...) {
78899       {
78900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78901       };
78902     }
78903   }
78904
78905   jresult = (void *)result;
78906   return jresult;
78907 }
78908
78909
78910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
78911   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78912
78913   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78914   {
78915     try {
78916       delete arg1;
78917     } catch (std::out_of_range& e) {
78918       {
78919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78920       };
78921     } catch (std::exception& e) {
78922       {
78923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78924       };
78925     } catch (Dali::DaliException e) {
78926       {
78927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78928       };
78929     } catch (...) {
78930       {
78931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78932       };
78933     }
78934   }
78935
78936 }
78937
78938
78939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
78940   void * jresult ;
78941   Dali::Toolkit::ScrollView result;
78942
78943   {
78944     try {
78945       result = Dali::Toolkit::ScrollView::New();
78946     } catch (std::out_of_range& e) {
78947       {
78948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78949       };
78950     } catch (std::exception& e) {
78951       {
78952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78953       };
78954     } catch (Dali::DaliException e) {
78955       {
78956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78957       };
78958     } catch (...) {
78959       {
78960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78961       };
78962     }
78963   }
78964
78965   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
78966   return jresult;
78967 }
78968
78969
78970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
78971   void * jresult ;
78972   Dali::BaseHandle arg1 ;
78973   Dali::BaseHandle *argp1 ;
78974   Dali::Toolkit::ScrollView result;
78975
78976   argp1 = (Dali::BaseHandle *)jarg1;
78977   if (!argp1) {
78978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78979     return 0;
78980   }
78981   arg1 = *argp1;
78982   {
78983     try {
78984       result = Dali::Toolkit::ScrollView::DownCast(arg1);
78985     } catch (std::out_of_range& e) {
78986       {
78987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78988       };
78989     } catch (std::exception& e) {
78990       {
78991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78992       };
78993     } catch (Dali::DaliException e) {
78994       {
78995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78996       };
78997     } catch (...) {
78998       {
78999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79000       };
79001     }
79002   }
79003
79004   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
79005   return jresult;
79006 }
79007
79008
79009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
79010   void * jresult ;
79011   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79012   Dali::AlphaFunction result;
79013
79014   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79015   {
79016     try {
79017       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
79018     } catch (std::out_of_range& e) {
79019       {
79020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79021       };
79022     } catch (std::exception& e) {
79023       {
79024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79025       };
79026     } catch (Dali::DaliException e) {
79027       {
79028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79029       };
79030     } catch (...) {
79031       {
79032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79033       };
79034     }
79035   }
79036
79037   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
79038   return jresult;
79039 }
79040
79041
79042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
79043   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79044   Dali::AlphaFunction arg2 ;
79045   Dali::AlphaFunction *argp2 ;
79046
79047   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79048   argp2 = (Dali::AlphaFunction *)jarg2;
79049   if (!argp2) {
79050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79051     return ;
79052   }
79053   arg2 = *argp2;
79054   {
79055     try {
79056       (arg1)->SetScrollSnapAlphaFunction(arg2);
79057     } catch (std::out_of_range& e) {
79058       {
79059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79060       };
79061     } catch (std::exception& e) {
79062       {
79063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79064       };
79065     } catch (Dali::DaliException e) {
79066       {
79067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79068       };
79069     } catch (...) {
79070       {
79071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79072       };
79073     }
79074   }
79075
79076 }
79077
79078
79079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
79080   void * jresult ;
79081   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79082   Dali::AlphaFunction result;
79083
79084   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79085   {
79086     try {
79087       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
79088     } catch (std::out_of_range& e) {
79089       {
79090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79091       };
79092     } catch (std::exception& e) {
79093       {
79094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79095       };
79096     } catch (Dali::DaliException e) {
79097       {
79098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79099       };
79100     } catch (...) {
79101       {
79102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79103       };
79104     }
79105   }
79106
79107   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
79108   return jresult;
79109 }
79110
79111
79112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
79113   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79114   Dali::AlphaFunction arg2 ;
79115   Dali::AlphaFunction *argp2 ;
79116
79117   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79118   argp2 = (Dali::AlphaFunction *)jarg2;
79119   if (!argp2) {
79120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79121     return ;
79122   }
79123   arg2 = *argp2;
79124   {
79125     try {
79126       (arg1)->SetScrollFlickAlphaFunction(arg2);
79127     } catch (std::out_of_range& e) {
79128       {
79129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79130       };
79131     } catch (std::exception& e) {
79132       {
79133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79134       };
79135     } catch (Dali::DaliException e) {
79136       {
79137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79138       };
79139     } catch (...) {
79140       {
79141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79142       };
79143     }
79144   }
79145
79146 }
79147
79148
79149 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
79150   float jresult ;
79151   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79152   float result;
79153
79154   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79155   {
79156     try {
79157       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
79158     } catch (std::out_of_range& e) {
79159       {
79160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79161       };
79162     } catch (std::exception& e) {
79163       {
79164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79165       };
79166     } catch (Dali::DaliException e) {
79167       {
79168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79169       };
79170     } catch (...) {
79171       {
79172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79173       };
79174     }
79175   }
79176
79177   jresult = result;
79178   return jresult;
79179 }
79180
79181
79182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
79183   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79184   float arg2 ;
79185
79186   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79187   arg2 = (float)jarg2;
79188   {
79189     try {
79190       (arg1)->SetScrollSnapDuration(arg2);
79191     } catch (std::out_of_range& e) {
79192       {
79193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79194       };
79195     } catch (std::exception& e) {
79196       {
79197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79198       };
79199     } catch (Dali::DaliException e) {
79200       {
79201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79202       };
79203     } catch (...) {
79204       {
79205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79206       };
79207     }
79208   }
79209
79210 }
79211
79212
79213 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
79214   float jresult ;
79215   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79216   float result;
79217
79218   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79219   {
79220     try {
79221       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
79222     } catch (std::out_of_range& e) {
79223       {
79224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79225       };
79226     } catch (std::exception& e) {
79227       {
79228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79229       };
79230     } catch (Dali::DaliException e) {
79231       {
79232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79233       };
79234     } catch (...) {
79235       {
79236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79237       };
79238     }
79239   }
79240
79241   jresult = result;
79242   return jresult;
79243 }
79244
79245
79246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
79247   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79248   float arg2 ;
79249
79250   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79251   arg2 = (float)jarg2;
79252   {
79253     try {
79254       (arg1)->SetScrollFlickDuration(arg2);
79255     } catch (std::out_of_range& e) {
79256       {
79257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79258       };
79259     } catch (std::exception& e) {
79260       {
79261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79262       };
79263     } catch (Dali::DaliException e) {
79264       {
79265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79266       };
79267     } catch (...) {
79268       {
79269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79270       };
79271     }
79272   }
79273
79274 }
79275
79276
79277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
79278   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79279   Dali::Toolkit::RulerPtr arg2 ;
79280   Dali::Toolkit::RulerPtr *argp2 ;
79281
79282   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79283   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
79284   if (!argp2) {
79285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
79286     return ;
79287   }
79288   arg2 = *argp2;
79289   {
79290     try {
79291       (arg1)->SetRulerX(arg2);
79292     } catch (std::out_of_range& e) {
79293       {
79294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79295       };
79296     } catch (std::exception& e) {
79297       {
79298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79299       };
79300     } catch (Dali::DaliException e) {
79301       {
79302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79303       };
79304     } catch (...) {
79305       {
79306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79307       };
79308     }
79309   }
79310
79311 }
79312
79313
79314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
79315   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79316   Dali::Toolkit::RulerPtr arg2 ;
79317   Dali::Toolkit::RulerPtr *argp2 ;
79318
79319   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79320   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
79321   if (!argp2) {
79322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
79323     return ;
79324   }
79325   arg2 = *argp2;
79326   {
79327     try {
79328       (arg1)->SetRulerY(arg2);
79329     } catch (std::out_of_range& e) {
79330       {
79331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79332       };
79333     } catch (std::exception& e) {
79334       {
79335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79336       };
79337     } catch (Dali::DaliException e) {
79338       {
79339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79340       };
79341     } catch (...) {
79342       {
79343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79344       };
79345     }
79346   }
79347
79348 }
79349
79350
79351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
79352   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79353   bool arg2 ;
79354
79355   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79356   arg2 = jarg2 ? true : false;
79357   {
79358     try {
79359       (arg1)->SetScrollSensitive(arg2);
79360     } catch (std::out_of_range& e) {
79361       {
79362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79363       };
79364     } catch (std::exception& e) {
79365       {
79366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79367       };
79368     } catch (Dali::DaliException e) {
79369       {
79370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79371       };
79372     } catch (...) {
79373       {
79374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79375       };
79376     }
79377   }
79378
79379 }
79380
79381
79382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
79383   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79384   float arg2 ;
79385   float arg3 ;
79386
79387   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79388   arg2 = (float)jarg2;
79389   arg3 = (float)jarg3;
79390   {
79391     try {
79392       (arg1)->SetMaxOvershoot(arg2,arg3);
79393     } catch (std::out_of_range& e) {
79394       {
79395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79396       };
79397     } catch (std::exception& e) {
79398       {
79399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79400       };
79401     } catch (Dali::DaliException e) {
79402       {
79403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79404       };
79405     } catch (...) {
79406       {
79407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79408       };
79409     }
79410   }
79411
79412 }
79413
79414
79415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
79416   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79417   Dali::AlphaFunction arg2 ;
79418   Dali::AlphaFunction *argp2 ;
79419
79420   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79421   argp2 = (Dali::AlphaFunction *)jarg2;
79422   if (!argp2) {
79423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79424     return ;
79425   }
79426   arg2 = *argp2;
79427   {
79428     try {
79429       (arg1)->SetSnapOvershootAlphaFunction(arg2);
79430     } catch (std::out_of_range& e) {
79431       {
79432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79433       };
79434     } catch (std::exception& e) {
79435       {
79436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79437       };
79438     } catch (Dali::DaliException e) {
79439       {
79440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79441       };
79442     } catch (...) {
79443       {
79444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79445       };
79446     }
79447   }
79448
79449 }
79450
79451
79452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
79453   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79454   float arg2 ;
79455
79456   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79457   arg2 = (float)jarg2;
79458   {
79459     try {
79460       (arg1)->SetSnapOvershootDuration(arg2);
79461     } catch (std::out_of_range& e) {
79462       {
79463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79464       };
79465     } catch (std::exception& e) {
79466       {
79467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79468       };
79469     } catch (Dali::DaliException e) {
79470       {
79471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79472       };
79473     } catch (...) {
79474       {
79475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79476       };
79477     }
79478   }
79479
79480 }
79481
79482
79483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
79484   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79485   bool arg2 ;
79486
79487   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79488   arg2 = jarg2 ? true : false;
79489   {
79490     try {
79491       (arg1)->SetActorAutoSnap(arg2);
79492     } catch (std::out_of_range& e) {
79493       {
79494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79495       };
79496     } catch (std::exception& e) {
79497       {
79498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79499       };
79500     } catch (Dali::DaliException e) {
79501       {
79502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79503       };
79504     } catch (...) {
79505       {
79506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79507       };
79508     }
79509   }
79510
79511 }
79512
79513
79514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
79515   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79516   bool arg2 ;
79517
79518   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79519   arg2 = jarg2 ? true : false;
79520   {
79521     try {
79522       (arg1)->SetWrapMode(arg2);
79523     } catch (std::out_of_range& e) {
79524       {
79525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79526       };
79527     } catch (std::exception& e) {
79528       {
79529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79530       };
79531     } catch (Dali::DaliException e) {
79532       {
79533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79534       };
79535     } catch (...) {
79536       {
79537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79538       };
79539     }
79540   }
79541
79542 }
79543
79544
79545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
79546   int jresult ;
79547   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79548   int result;
79549
79550   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79551   {
79552     try {
79553       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
79554     } catch (std::out_of_range& e) {
79555       {
79556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79557       };
79558     } catch (std::exception& e) {
79559       {
79560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79561       };
79562     } catch (Dali::DaliException e) {
79563       {
79564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79565       };
79566     } catch (...) {
79567       {
79568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79569       };
79570     }
79571   }
79572
79573   jresult = result;
79574   return jresult;
79575 }
79576
79577
79578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
79579   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79580   int arg2 ;
79581
79582   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79583   arg2 = (int)jarg2;
79584   {
79585     try {
79586       (arg1)->SetScrollUpdateDistance(arg2);
79587     } catch (std::out_of_range& e) {
79588       {
79589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79590       };
79591     } catch (std::exception& e) {
79592       {
79593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79594       };
79595     } catch (Dali::DaliException e) {
79596       {
79597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79598       };
79599     } catch (...) {
79600       {
79601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79602       };
79603     }
79604   }
79605
79606 }
79607
79608
79609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
79610   unsigned int jresult ;
79611   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79612   bool result;
79613
79614   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79615   {
79616     try {
79617       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
79618     } catch (std::out_of_range& e) {
79619       {
79620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79621       };
79622     } catch (std::exception& e) {
79623       {
79624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79625       };
79626     } catch (Dali::DaliException e) {
79627       {
79628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79629       };
79630     } catch (...) {
79631       {
79632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79633       };
79634     }
79635   }
79636
79637   jresult = result;
79638   return jresult;
79639 }
79640
79641
79642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
79643   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79644   bool arg2 ;
79645
79646   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79647   arg2 = jarg2 ? true : false;
79648   {
79649     try {
79650       (arg1)->SetAxisAutoLock(arg2);
79651     } catch (std::out_of_range& e) {
79652       {
79653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79654       };
79655     } catch (std::exception& e) {
79656       {
79657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79658       };
79659     } catch (Dali::DaliException e) {
79660       {
79661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79662       };
79663     } catch (...) {
79664       {
79665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79666       };
79667     }
79668   }
79669
79670 }
79671
79672
79673 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
79674   float jresult ;
79675   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79676   float result;
79677
79678   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79679   {
79680     try {
79681       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
79682     } catch (std::out_of_range& e) {
79683       {
79684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79685       };
79686     } catch (std::exception& e) {
79687       {
79688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79689       };
79690     } catch (Dali::DaliException e) {
79691       {
79692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79693       };
79694     } catch (...) {
79695       {
79696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79697       };
79698     }
79699   }
79700
79701   jresult = result;
79702   return jresult;
79703 }
79704
79705
79706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
79707   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79708   float arg2 ;
79709
79710   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79711   arg2 = (float)jarg2;
79712   {
79713     try {
79714       (arg1)->SetAxisAutoLockGradient(arg2);
79715     } catch (std::out_of_range& e) {
79716       {
79717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79718       };
79719     } catch (std::exception& e) {
79720       {
79721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79722       };
79723     } catch (Dali::DaliException e) {
79724       {
79725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79726       };
79727     } catch (...) {
79728       {
79729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79730       };
79731     }
79732   }
79733
79734 }
79735
79736
79737 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
79738   float jresult ;
79739   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79740   float result;
79741
79742   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79743   {
79744     try {
79745       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
79746     } catch (std::out_of_range& e) {
79747       {
79748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79749       };
79750     } catch (std::exception& e) {
79751       {
79752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79753       };
79754     } catch (Dali::DaliException e) {
79755       {
79756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79757       };
79758     } catch (...) {
79759       {
79760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79761       };
79762     }
79763   }
79764
79765   jresult = result;
79766   return jresult;
79767 }
79768
79769
79770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
79771   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79772   float arg2 ;
79773
79774   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79775   arg2 = (float)jarg2;
79776   {
79777     try {
79778       (arg1)->SetFrictionCoefficient(arg2);
79779     } catch (std::out_of_range& e) {
79780       {
79781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79782       };
79783     } catch (std::exception& e) {
79784       {
79785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79786       };
79787     } catch (Dali::DaliException e) {
79788       {
79789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79790       };
79791     } catch (...) {
79792       {
79793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79794       };
79795     }
79796   }
79797
79798 }
79799
79800
79801 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
79802   float jresult ;
79803   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79804   float result;
79805
79806   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79807   {
79808     try {
79809       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
79810     } catch (std::out_of_range& e) {
79811       {
79812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79813       };
79814     } catch (std::exception& e) {
79815       {
79816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79817       };
79818     } catch (Dali::DaliException e) {
79819       {
79820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79821       };
79822     } catch (...) {
79823       {
79824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79825       };
79826     }
79827   }
79828
79829   jresult = result;
79830   return jresult;
79831 }
79832
79833
79834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
79835   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79836   float arg2 ;
79837
79838   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79839   arg2 = (float)jarg2;
79840   {
79841     try {
79842       (arg1)->SetFlickSpeedCoefficient(arg2);
79843     } catch (std::out_of_range& e) {
79844       {
79845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79846       };
79847     } catch (std::exception& e) {
79848       {
79849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79850       };
79851     } catch (Dali::DaliException e) {
79852       {
79853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79854       };
79855     } catch (...) {
79856       {
79857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79858       };
79859     }
79860   }
79861
79862 }
79863
79864
79865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
79866   void * jresult ;
79867   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79868   Dali::Vector2 result;
79869
79870   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79871   {
79872     try {
79873       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
79874     } catch (std::out_of_range& e) {
79875       {
79876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79877       };
79878     } catch (std::exception& e) {
79879       {
79880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79881       };
79882     } catch (Dali::DaliException e) {
79883       {
79884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79885       };
79886     } catch (...) {
79887       {
79888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79889       };
79890     }
79891   }
79892
79893   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79894   return jresult;
79895 }
79896
79897
79898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
79899   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79900   Dali::Vector2 *arg2 = 0 ;
79901
79902   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79903   arg2 = (Dali::Vector2 *)jarg2;
79904   if (!arg2) {
79905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
79906     return ;
79907   }
79908   {
79909     try {
79910       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
79911     } catch (std::out_of_range& e) {
79912       {
79913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79914       };
79915     } catch (std::exception& e) {
79916       {
79917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79918       };
79919     } catch (Dali::DaliException e) {
79920       {
79921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79922       };
79923     } catch (...) {
79924       {
79925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79926       };
79927     }
79928   }
79929
79930 }
79931
79932
79933 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
79934   float jresult ;
79935   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79936   float result;
79937
79938   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79939   {
79940     try {
79941       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
79942     } catch (std::out_of_range& e) {
79943       {
79944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79945       };
79946     } catch (std::exception& e) {
79947       {
79948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79949       };
79950     } catch (Dali::DaliException e) {
79951       {
79952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79953       };
79954     } catch (...) {
79955       {
79956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79957       };
79958     }
79959   }
79960
79961   jresult = result;
79962   return jresult;
79963 }
79964
79965
79966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
79967   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79968   float arg2 ;
79969
79970   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79971   arg2 = (float)jarg2;
79972   {
79973     try {
79974       (arg1)->SetMinimumSpeedForFlick(arg2);
79975     } catch (std::out_of_range& e) {
79976       {
79977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79978       };
79979     } catch (std::exception& e) {
79980       {
79981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79982       };
79983     } catch (Dali::DaliException e) {
79984       {
79985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79986       };
79987     } catch (...) {
79988       {
79989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79990       };
79991     }
79992   }
79993
79994 }
79995
79996
79997 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
79998   float jresult ;
79999   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80000   float result;
80001
80002   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80003   {
80004     try {
80005       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
80006     } catch (std::out_of_range& e) {
80007       {
80008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80009       };
80010     } catch (std::exception& e) {
80011       {
80012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80013       };
80014     } catch (Dali::DaliException e) {
80015       {
80016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80017       };
80018     } catch (...) {
80019       {
80020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80021       };
80022     }
80023   }
80024
80025   jresult = result;
80026   return jresult;
80027 }
80028
80029
80030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
80031   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80032   float arg2 ;
80033
80034   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80035   arg2 = (float)jarg2;
80036   {
80037     try {
80038       (arg1)->SetMaxFlickSpeed(arg2);
80039     } catch (std::out_of_range& e) {
80040       {
80041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80042       };
80043     } catch (std::exception& e) {
80044       {
80045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80046       };
80047     } catch (Dali::DaliException e) {
80048       {
80049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80050       };
80051     } catch (...) {
80052       {
80053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80054       };
80055     }
80056   }
80057
80058 }
80059
80060
80061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
80062   void * jresult ;
80063   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80064   Dali::Vector2 result;
80065
80066   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80067   {
80068     try {
80069       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
80070     } catch (std::out_of_range& e) {
80071       {
80072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80073       };
80074     } catch (std::exception& e) {
80075       {
80076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80077       };
80078     } catch (Dali::DaliException e) {
80079       {
80080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80081       };
80082     } catch (...) {
80083       {
80084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80085       };
80086     }
80087   }
80088
80089   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80090   return jresult;
80091 }
80092
80093
80094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
80095   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80096   Dali::Vector2 arg2 ;
80097   Dali::Vector2 *argp2 ;
80098
80099   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80100   argp2 = (Dali::Vector2 *)jarg2;
80101   if (!argp2) {
80102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
80103     return ;
80104   }
80105   arg2 = *argp2;
80106   {
80107     try {
80108       (arg1)->SetWheelScrollDistanceStep(arg2);
80109     } catch (std::out_of_range& e) {
80110       {
80111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80112       };
80113     } catch (std::exception& e) {
80114       {
80115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80116       };
80117     } catch (Dali::DaliException e) {
80118       {
80119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80120       };
80121     } catch (...) {
80122       {
80123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80124       };
80125     }
80126   }
80127
80128 }
80129
80130
80131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
80132   void * jresult ;
80133   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80134   Dali::Vector2 result;
80135
80136   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80137   {
80138     try {
80139       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
80140     } catch (std::out_of_range& e) {
80141       {
80142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80143       };
80144     } catch (std::exception& e) {
80145       {
80146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80147       };
80148     } catch (Dali::DaliException e) {
80149       {
80150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80151       };
80152     } catch (...) {
80153       {
80154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80155       };
80156     }
80157   }
80158
80159   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80160   return jresult;
80161 }
80162
80163
80164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
80165   unsigned int jresult ;
80166   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80167   unsigned int result;
80168
80169   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80170   {
80171     try {
80172       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
80173     } catch (std::out_of_range& e) {
80174       {
80175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80176       };
80177     } catch (std::exception& e) {
80178       {
80179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80180       };
80181     } catch (Dali::DaliException e) {
80182       {
80183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80184       };
80185     } catch (...) {
80186       {
80187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80188       };
80189     }
80190   }
80191
80192   jresult = result;
80193   return jresult;
80194 }
80195
80196
80197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
80198   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80199   Dali::Vector2 *arg2 = 0 ;
80200
80201   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80202   arg2 = (Dali::Vector2 *)jarg2;
80203   if (!arg2) {
80204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80205     return ;
80206   }
80207   {
80208     try {
80209       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
80210     } catch (std::out_of_range& e) {
80211       {
80212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80213       };
80214     } catch (std::exception& e) {
80215       {
80216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80217       };
80218     } catch (Dali::DaliException e) {
80219       {
80220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80221       };
80222     } catch (...) {
80223       {
80224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80225       };
80226     }
80227   }
80228
80229 }
80230
80231
80232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
80233   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80234   Dali::Vector2 *arg2 = 0 ;
80235   float arg3 ;
80236
80237   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80238   arg2 = (Dali::Vector2 *)jarg2;
80239   if (!arg2) {
80240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80241     return ;
80242   }
80243   arg3 = (float)jarg3;
80244   {
80245     try {
80246       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
80247     } catch (std::out_of_range& e) {
80248       {
80249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80250       };
80251     } catch (std::exception& e) {
80252       {
80253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80254       };
80255     } catch (Dali::DaliException e) {
80256       {
80257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80258       };
80259     } catch (...) {
80260       {
80261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80262       };
80263     }
80264   }
80265
80266 }
80267
80268
80269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
80270   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80271   Dali::Vector2 *arg2 = 0 ;
80272   float arg3 ;
80273   Dali::AlphaFunction arg4 ;
80274   Dali::AlphaFunction *argp4 ;
80275
80276   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80277   arg2 = (Dali::Vector2 *)jarg2;
80278   if (!arg2) {
80279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80280     return ;
80281   }
80282   arg3 = (float)jarg3;
80283   argp4 = (Dali::AlphaFunction *)jarg4;
80284   if (!argp4) {
80285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80286     return ;
80287   }
80288   arg4 = *argp4;
80289   {
80290     try {
80291       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
80292     } catch (std::out_of_range& e) {
80293       {
80294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80295       };
80296     } catch (std::exception& e) {
80297       {
80298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80299       };
80300     } catch (Dali::DaliException e) {
80301       {
80302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80303       };
80304     } catch (...) {
80305       {
80306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80307       };
80308     }
80309   }
80310
80311 }
80312
80313
80314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
80315   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80316   Dali::Vector2 *arg2 = 0 ;
80317   float arg3 ;
80318   Dali::Toolkit::DirectionBias arg4 ;
80319   Dali::Toolkit::DirectionBias arg5 ;
80320
80321   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80322   arg2 = (Dali::Vector2 *)jarg2;
80323   if (!arg2) {
80324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80325     return ;
80326   }
80327   arg3 = (float)jarg3;
80328   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
80329   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
80330   {
80331     try {
80332       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
80333     } catch (std::out_of_range& e) {
80334       {
80335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80336       };
80337     } catch (std::exception& e) {
80338       {
80339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80340       };
80341     } catch (Dali::DaliException e) {
80342       {
80343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80344       };
80345     } catch (...) {
80346       {
80347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80348       };
80349     }
80350   }
80351
80352 }
80353
80354
80355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
80356   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80357   Dali::Vector2 *arg2 = 0 ;
80358   float arg3 ;
80359   Dali::AlphaFunction arg4 ;
80360   Dali::Toolkit::DirectionBias arg5 ;
80361   Dali::Toolkit::DirectionBias arg6 ;
80362   Dali::AlphaFunction *argp4 ;
80363
80364   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80365   arg2 = (Dali::Vector2 *)jarg2;
80366   if (!arg2) {
80367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80368     return ;
80369   }
80370   arg3 = (float)jarg3;
80371   argp4 = (Dali::AlphaFunction *)jarg4;
80372   if (!argp4) {
80373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80374     return ;
80375   }
80376   arg4 = *argp4;
80377   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
80378   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
80379   {
80380     try {
80381       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
80382     } catch (std::out_of_range& e) {
80383       {
80384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80385       };
80386     } catch (std::exception& e) {
80387       {
80388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80389       };
80390     } catch (Dali::DaliException e) {
80391       {
80392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80393       };
80394     } catch (...) {
80395       {
80396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80397       };
80398     }
80399   }
80400
80401 }
80402
80403
80404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
80405   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80406   unsigned int arg2 ;
80407
80408   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80409   arg2 = (unsigned int)jarg2;
80410   {
80411     try {
80412       (arg1)->ScrollTo(arg2);
80413     } catch (std::out_of_range& e) {
80414       {
80415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80416       };
80417     } catch (std::exception& e) {
80418       {
80419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80420       };
80421     } catch (Dali::DaliException e) {
80422       {
80423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80424       };
80425     } catch (...) {
80426       {
80427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80428       };
80429     }
80430   }
80431
80432 }
80433
80434
80435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
80436   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80437   unsigned int arg2 ;
80438   float arg3 ;
80439
80440   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80441   arg2 = (unsigned int)jarg2;
80442   arg3 = (float)jarg3;
80443   {
80444     try {
80445       (arg1)->ScrollTo(arg2,arg3);
80446     } catch (std::out_of_range& e) {
80447       {
80448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80449       };
80450     } catch (std::exception& e) {
80451       {
80452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80453       };
80454     } catch (Dali::DaliException e) {
80455       {
80456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80457       };
80458     } catch (...) {
80459       {
80460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80461       };
80462     }
80463   }
80464
80465 }
80466
80467
80468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
80469   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80470   unsigned int arg2 ;
80471   float arg3 ;
80472   Dali::Toolkit::DirectionBias arg4 ;
80473
80474   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80475   arg2 = (unsigned int)jarg2;
80476   arg3 = (float)jarg3;
80477   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
80478   {
80479     try {
80480       (arg1)->ScrollTo(arg2,arg3,arg4);
80481     } catch (std::out_of_range& e) {
80482       {
80483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80484       };
80485     } catch (std::exception& e) {
80486       {
80487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80488       };
80489     } catch (Dali::DaliException e) {
80490       {
80491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80492       };
80493     } catch (...) {
80494       {
80495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80496       };
80497     }
80498   }
80499
80500 }
80501
80502
80503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
80504   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80505   Dali::Actor *arg2 = 0 ;
80506
80507   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80508   arg2 = (Dali::Actor *)jarg2;
80509   if (!arg2) {
80510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
80511     return ;
80512   }
80513   {
80514     try {
80515       (arg1)->ScrollTo(*arg2);
80516     } catch (std::out_of_range& e) {
80517       {
80518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80519       };
80520     } catch (std::exception& e) {
80521       {
80522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80523       };
80524     } catch (Dali::DaliException e) {
80525       {
80526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80527       };
80528     } catch (...) {
80529       {
80530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80531       };
80532     }
80533   }
80534
80535 }
80536
80537
80538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
80539   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80540   Dali::Actor *arg2 = 0 ;
80541   float arg3 ;
80542
80543   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80544   arg2 = (Dali::Actor *)jarg2;
80545   if (!arg2) {
80546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
80547     return ;
80548   }
80549   arg3 = (float)jarg3;
80550   {
80551     try {
80552       (arg1)->ScrollTo(*arg2,arg3);
80553     } catch (std::out_of_range& e) {
80554       {
80555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80556       };
80557     } catch (std::exception& e) {
80558       {
80559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80560       };
80561     } catch (Dali::DaliException e) {
80562       {
80563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80564       };
80565     } catch (...) {
80566       {
80567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80568       };
80569     }
80570   }
80571
80572 }
80573
80574
80575 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
80576   unsigned int jresult ;
80577   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80578   bool result;
80579
80580   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80581   {
80582     try {
80583       result = (bool)(arg1)->ScrollToSnapPoint();
80584     } catch (std::out_of_range& e) {
80585       {
80586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80587       };
80588     } catch (std::exception& e) {
80589       {
80590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80591       };
80592     } catch (Dali::DaliException e) {
80593       {
80594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80595       };
80596     } catch (...) {
80597       {
80598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80599       };
80600     }
80601   }
80602
80603   jresult = result;
80604   return jresult;
80605 }
80606
80607
80608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
80609   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80610   Dali::Constraint arg2 ;
80611   Dali::Constraint *argp2 ;
80612
80613   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80614   argp2 = (Dali::Constraint *)jarg2;
80615   if (!argp2) {
80616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
80617     return ;
80618   }
80619   arg2 = *argp2;
80620   {
80621     try {
80622       (arg1)->ApplyConstraintToChildren(arg2);
80623     } catch (std::out_of_range& e) {
80624       {
80625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80626       };
80627     } catch (std::exception& e) {
80628       {
80629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80630       };
80631     } catch (Dali::DaliException e) {
80632       {
80633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80634       };
80635     } catch (...) {
80636       {
80637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80638       };
80639     }
80640   }
80641
80642 }
80643
80644
80645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
80646   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80647
80648   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80649   {
80650     try {
80651       (arg1)->RemoveConstraintsFromChildren();
80652     } catch (std::out_of_range& e) {
80653       {
80654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80655       };
80656     } catch (std::exception& e) {
80657       {
80658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80659       };
80660     } catch (Dali::DaliException e) {
80661       {
80662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80663       };
80664     } catch (...) {
80665       {
80666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80667       };
80668     }
80669   }
80670
80671 }
80672
80673
80674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
80675   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80676   Dali::Toolkit::ScrollViewEffect arg2 ;
80677   Dali::Toolkit::ScrollViewEffect *argp2 ;
80678
80679   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80680   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
80681   if (!argp2) {
80682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
80683     return ;
80684   }
80685   arg2 = *argp2;
80686   {
80687     try {
80688       (arg1)->ApplyEffect(arg2);
80689     } catch (std::out_of_range& e) {
80690       {
80691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80692       };
80693     } catch (std::exception& e) {
80694       {
80695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80696       };
80697     } catch (Dali::DaliException e) {
80698       {
80699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80700       };
80701     } catch (...) {
80702       {
80703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80704       };
80705     }
80706   }
80707
80708 }
80709
80710
80711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
80712   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80713   Dali::Toolkit::ScrollViewEffect arg2 ;
80714   Dali::Toolkit::ScrollViewEffect *argp2 ;
80715
80716   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80717   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
80718   if (!argp2) {
80719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
80720     return ;
80721   }
80722   arg2 = *argp2;
80723   {
80724     try {
80725       (arg1)->RemoveEffect(arg2);
80726     } catch (std::out_of_range& e) {
80727       {
80728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80729       };
80730     } catch (std::exception& e) {
80731       {
80732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80733       };
80734     } catch (Dali::DaliException e) {
80735       {
80736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80737       };
80738     } catch (...) {
80739       {
80740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80741       };
80742     }
80743   }
80744
80745 }
80746
80747
80748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
80749   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80750
80751   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80752   {
80753     try {
80754       (arg1)->RemoveAllEffects();
80755     } catch (std::out_of_range& e) {
80756       {
80757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80758       };
80759     } catch (std::exception& e) {
80760       {
80761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80762       };
80763     } catch (Dali::DaliException e) {
80764       {
80765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80766       };
80767     } catch (...) {
80768       {
80769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80770       };
80771     }
80772   }
80773
80774 }
80775
80776
80777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
80778   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80779   Dali::Actor arg2 ;
80780   Dali::Actor *argp2 ;
80781
80782   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80783   argp2 = (Dali::Actor *)jarg2;
80784   if (!argp2) {
80785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80786     return ;
80787   }
80788   arg2 = *argp2;
80789   {
80790     try {
80791       (arg1)->BindActor(arg2);
80792     } catch (std::out_of_range& e) {
80793       {
80794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80795       };
80796     } catch (std::exception& e) {
80797       {
80798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80799       };
80800     } catch (Dali::DaliException e) {
80801       {
80802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80803       };
80804     } catch (...) {
80805       {
80806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80807       };
80808     }
80809   }
80810
80811 }
80812
80813
80814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
80815   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80816   Dali::Actor arg2 ;
80817   Dali::Actor *argp2 ;
80818
80819   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80820   argp2 = (Dali::Actor *)jarg2;
80821   if (!argp2) {
80822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80823     return ;
80824   }
80825   arg2 = *argp2;
80826   {
80827     try {
80828       (arg1)->UnbindActor(arg2);
80829     } catch (std::out_of_range& e) {
80830       {
80831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80832       };
80833     } catch (std::exception& e) {
80834       {
80835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80836       };
80837     } catch (Dali::DaliException e) {
80838       {
80839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80840       };
80841     } catch (...) {
80842       {
80843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80844       };
80845     }
80846   }
80847
80848 }
80849
80850
80851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
80852   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80853   Dali::Radian arg2 ;
80854   Dali::Radian arg3 ;
80855   Dali::Radian *argp2 ;
80856   Dali::Radian *argp3 ;
80857
80858   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80859   argp2 = (Dali::Radian *)jarg2;
80860   if (!argp2) {
80861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80862     return ;
80863   }
80864   arg2 = *argp2;
80865   argp3 = (Dali::Radian *)jarg3;
80866   if (!argp3) {
80867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80868     return ;
80869   }
80870   arg3 = *argp3;
80871   {
80872     try {
80873       (arg1)->SetScrollingDirection(arg2,arg3);
80874     } catch (std::out_of_range& e) {
80875       {
80876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80877       };
80878     } catch (std::exception& e) {
80879       {
80880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80881       };
80882     } catch (Dali::DaliException e) {
80883       {
80884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80885       };
80886     } catch (...) {
80887       {
80888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80889       };
80890     }
80891   }
80892
80893 }
80894
80895
80896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
80897   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80898   Dali::Radian arg2 ;
80899   Dali::Radian *argp2 ;
80900
80901   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80902   argp2 = (Dali::Radian *)jarg2;
80903   if (!argp2) {
80904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80905     return ;
80906   }
80907   arg2 = *argp2;
80908   {
80909     try {
80910       (arg1)->SetScrollingDirection(arg2);
80911     } catch (std::out_of_range& e) {
80912       {
80913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80914       };
80915     } catch (std::exception& e) {
80916       {
80917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80918       };
80919     } catch (Dali::DaliException e) {
80920       {
80921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80922       };
80923     } catch (...) {
80924       {
80925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80926       };
80927     }
80928   }
80929
80930 }
80931
80932
80933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
80934   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80935   Dali::Radian arg2 ;
80936   Dali::Radian *argp2 ;
80937
80938   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80939   argp2 = (Dali::Radian *)jarg2;
80940   if (!argp2) {
80941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80942     return ;
80943   }
80944   arg2 = *argp2;
80945   {
80946     try {
80947       (arg1)->RemoveScrollingDirection(arg2);
80948     } catch (std::out_of_range& e) {
80949       {
80950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80951       };
80952     } catch (std::exception& e) {
80953       {
80954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80955       };
80956     } catch (Dali::DaliException e) {
80957       {
80958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80959       };
80960     } catch (...) {
80961       {
80962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80963       };
80964     }
80965   }
80966
80967 }
80968
80969
80970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
80971   void * jresult ;
80972   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80973   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
80974
80975   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80976   {
80977     try {
80978       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
80979     } catch (std::out_of_range& e) {
80980       {
80981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80982       };
80983     } catch (std::exception& e) {
80984       {
80985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80986       };
80987     } catch (Dali::DaliException e) {
80988       {
80989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80990       };
80991     } catch (...) {
80992       {
80993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80994       };
80995     }
80996   }
80997
80998   jresult = (void *)result;
80999   return jresult;
81000 }
81001
81002
81003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
81004   int jresult ;
81005   int result;
81006
81007   result = (int)Dali::Toolkit::TableView::Property::ROWS;
81008   jresult = (int)result;
81009   return jresult;
81010 }
81011
81012
81013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
81014   int jresult ;
81015   int result;
81016
81017   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
81018   jresult = (int)result;
81019   return jresult;
81020 }
81021
81022
81023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
81024   int jresult ;
81025   int result;
81026
81027   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
81028   jresult = (int)result;
81029   return jresult;
81030 }
81031
81032
81033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
81034   int jresult ;
81035   int result;
81036
81037   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
81038   jresult = (int)result;
81039   return jresult;
81040 }
81041
81042
81043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
81044   int jresult ;
81045   int result;
81046
81047   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
81048   jresult = (int)result;
81049   return jresult;
81050 }
81051
81052
81053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
81054   void * jresult ;
81055   Dali::Toolkit::TableView::Property *result = 0 ;
81056
81057   {
81058     try {
81059       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
81060     } catch (std::out_of_range& e) {
81061       {
81062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81063       };
81064     } catch (std::exception& e) {
81065       {
81066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81067       };
81068     } catch (Dali::DaliException e) {
81069       {
81070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81071       };
81072     } catch (...) {
81073       {
81074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81075       };
81076     }
81077   }
81078
81079   jresult = (void *)result;
81080   return jresult;
81081 }
81082
81083
81084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
81085   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
81086
81087   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
81088   {
81089     try {
81090       delete arg1;
81091     } catch (std::out_of_range& e) {
81092       {
81093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81094       };
81095     } catch (std::exception& e) {
81096       {
81097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81098       };
81099     } catch (Dali::DaliException e) {
81100       {
81101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81102       };
81103     } catch (...) {
81104       {
81105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81106       };
81107     }
81108   }
81109
81110 }
81111
81112
81113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
81114   int jresult ;
81115   int result;
81116
81117   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
81118   jresult = (int)result;
81119   return jresult;
81120 }
81121
81122
81123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
81124   int jresult ;
81125   int result;
81126
81127   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
81128   jresult = (int)result;
81129   return jresult;
81130 }
81131
81132
81133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
81134   int jresult ;
81135   int result;
81136
81137   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
81138   jresult = (int)result;
81139   return jresult;
81140 }
81141
81142
81143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
81144   int jresult ;
81145   int result;
81146
81147   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
81148   jresult = (int)result;
81149   return jresult;
81150 }
81151
81152
81153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
81154   int jresult ;
81155   int result;
81156
81157   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
81158   jresult = (int)result;
81159   return jresult;
81160 }
81161
81162
81163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
81164   void * jresult ;
81165   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
81166
81167   {
81168     try {
81169       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
81170     } catch (std::out_of_range& e) {
81171       {
81172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81173       };
81174     } catch (std::exception& e) {
81175       {
81176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81177       };
81178     } catch (Dali::DaliException e) {
81179       {
81180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81181       };
81182     } catch (...) {
81183       {
81184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81185       };
81186     }
81187   }
81188
81189   jresult = (void *)result;
81190   return jresult;
81191 }
81192
81193
81194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
81195   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
81196
81197   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
81198   {
81199     try {
81200       delete arg1;
81201     } catch (std::out_of_range& e) {
81202       {
81203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81204       };
81205     } catch (std::exception& e) {
81206       {
81207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81208       };
81209     } catch (Dali::DaliException e) {
81210       {
81211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81212       };
81213     } catch (...) {
81214       {
81215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81216       };
81217     }
81218   }
81219
81220 }
81221
81222
81223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
81224   void * jresult ;
81225   unsigned int arg1 ;
81226   unsigned int arg2 ;
81227   unsigned int arg3 ;
81228   unsigned int arg4 ;
81229   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81230
81231   arg1 = (unsigned int)jarg1;
81232   arg2 = (unsigned int)jarg2;
81233   arg3 = (unsigned int)jarg3;
81234   arg4 = (unsigned int)jarg4;
81235   {
81236     try {
81237       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
81238     } catch (std::out_of_range& e) {
81239       {
81240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81241       };
81242     } catch (std::exception& e) {
81243       {
81244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81245       };
81246     } catch (Dali::DaliException e) {
81247       {
81248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81249       };
81250     } catch (...) {
81251       {
81252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81253       };
81254     }
81255   }
81256
81257   jresult = (void *)result;
81258   return jresult;
81259 }
81260
81261
81262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
81263   void * jresult ;
81264   unsigned int arg1 ;
81265   unsigned int arg2 ;
81266   unsigned int arg3 ;
81267   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81268
81269   arg1 = (unsigned int)jarg1;
81270   arg2 = (unsigned int)jarg2;
81271   arg3 = (unsigned int)jarg3;
81272   {
81273     try {
81274       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
81275     } catch (std::out_of_range& e) {
81276       {
81277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81278       };
81279     } catch (std::exception& e) {
81280       {
81281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81282       };
81283     } catch (Dali::DaliException e) {
81284       {
81285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81286       };
81287     } catch (...) {
81288       {
81289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81290       };
81291     }
81292   }
81293
81294   jresult = (void *)result;
81295   return jresult;
81296 }
81297
81298
81299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
81300   void * jresult ;
81301   unsigned int arg1 ;
81302   unsigned int arg2 ;
81303   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81304
81305   arg1 = (unsigned int)jarg1;
81306   arg2 = (unsigned int)jarg2;
81307   {
81308     try {
81309       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
81310     } catch (std::out_of_range& e) {
81311       {
81312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81313       };
81314     } catch (std::exception& e) {
81315       {
81316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81317       };
81318     } catch (Dali::DaliException e) {
81319       {
81320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81321       };
81322     } catch (...) {
81323       {
81324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81325       };
81326     }
81327   }
81328
81329   jresult = (void *)result;
81330   return jresult;
81331 }
81332
81333
81334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
81335   void * jresult ;
81336   unsigned int arg1 ;
81337   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81338
81339   arg1 = (unsigned int)jarg1;
81340   {
81341     try {
81342       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
81343     } catch (std::out_of_range& e) {
81344       {
81345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81346       };
81347     } catch (std::exception& e) {
81348       {
81349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81350       };
81351     } catch (Dali::DaliException e) {
81352       {
81353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81354       };
81355     } catch (...) {
81356       {
81357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81358       };
81359     }
81360   }
81361
81362   jresult = (void *)result;
81363   return jresult;
81364 }
81365
81366
81367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
81368   void * jresult ;
81369   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81370
81371   {
81372     try {
81373       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
81374     } catch (std::out_of_range& e) {
81375       {
81376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81377       };
81378     } catch (std::exception& e) {
81379       {
81380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81381       };
81382     } catch (Dali::DaliException e) {
81383       {
81384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81385       };
81386     } catch (...) {
81387       {
81388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81389       };
81390     }
81391   }
81392
81393   jresult = (void *)result;
81394   return jresult;
81395 }
81396
81397
81398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
81399   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81400   unsigned int arg2 ;
81401
81402   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81403   arg2 = (unsigned int)jarg2;
81404   if (arg1) (arg1)->rowIndex = arg2;
81405 }
81406
81407
81408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
81409   unsigned int jresult ;
81410   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81411   unsigned int result;
81412
81413   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81414   result = (unsigned int) ((arg1)->rowIndex);
81415   jresult = result;
81416   return jresult;
81417 }
81418
81419
81420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
81421   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81422   unsigned int arg2 ;
81423
81424   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81425   arg2 = (unsigned int)jarg2;
81426   if (arg1) (arg1)->columnIndex = arg2;
81427 }
81428
81429
81430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
81431   unsigned int jresult ;
81432   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81433   unsigned int result;
81434
81435   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81436   result = (unsigned int) ((arg1)->columnIndex);
81437   jresult = result;
81438   return jresult;
81439 }
81440
81441
81442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
81443   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81444   unsigned int arg2 ;
81445
81446   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81447   arg2 = (unsigned int)jarg2;
81448   if (arg1) (arg1)->rowSpan = arg2;
81449 }
81450
81451
81452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
81453   unsigned int jresult ;
81454   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81455   unsigned int result;
81456
81457   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81458   result = (unsigned int) ((arg1)->rowSpan);
81459   jresult = result;
81460   return jresult;
81461 }
81462
81463
81464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
81465   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81466   unsigned int arg2 ;
81467
81468   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81469   arg2 = (unsigned int)jarg2;
81470   if (arg1) (arg1)->columnSpan = arg2;
81471 }
81472
81473
81474 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
81475   unsigned int jresult ;
81476   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81477   unsigned int result;
81478
81479   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81480   result = (unsigned int) ((arg1)->columnSpan);
81481   jresult = result;
81482   return jresult;
81483 }
81484
81485
81486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
81487   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81488
81489   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81490   {
81491     try {
81492       delete arg1;
81493     } catch (std::out_of_range& e) {
81494       {
81495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81496       };
81497     } catch (std::exception& e) {
81498       {
81499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81500       };
81501     } catch (Dali::DaliException e) {
81502       {
81503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81504       };
81505     } catch (...) {
81506       {
81507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81508       };
81509     }
81510   }
81511
81512 }
81513
81514
81515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
81516   void * jresult ;
81517   Dali::Toolkit::TableView *result = 0 ;
81518
81519   {
81520     try {
81521       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
81522     } catch (std::out_of_range& e) {
81523       {
81524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81525       };
81526     } catch (std::exception& e) {
81527       {
81528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81529       };
81530     } catch (Dali::DaliException e) {
81531       {
81532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81533       };
81534     } catch (...) {
81535       {
81536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81537       };
81538     }
81539   }
81540
81541   jresult = (void *)result;
81542   return jresult;
81543 }
81544
81545
81546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
81547   void * jresult ;
81548   Dali::Toolkit::TableView *arg1 = 0 ;
81549   Dali::Toolkit::TableView *result = 0 ;
81550
81551   arg1 = (Dali::Toolkit::TableView *)jarg1;
81552   if (!arg1) {
81553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
81554     return 0;
81555   }
81556   {
81557     try {
81558       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
81559     } catch (std::out_of_range& e) {
81560       {
81561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81562       };
81563     } catch (std::exception& e) {
81564       {
81565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81566       };
81567     } catch (Dali::DaliException e) {
81568       {
81569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81570       };
81571     } catch (...) {
81572       {
81573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81574       };
81575     }
81576   }
81577
81578   jresult = (void *)result;
81579   return jresult;
81580 }
81581
81582
81583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
81584   void * jresult ;
81585   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81586   Dali::Toolkit::TableView *arg2 = 0 ;
81587   Dali::Toolkit::TableView *result = 0 ;
81588
81589   arg1 = (Dali::Toolkit::TableView *)jarg1;
81590   arg2 = (Dali::Toolkit::TableView *)jarg2;
81591   if (!arg2) {
81592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
81593     return 0;
81594   }
81595   {
81596     try {
81597       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
81598     } catch (std::out_of_range& e) {
81599       {
81600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81601       };
81602     } catch (std::exception& e) {
81603       {
81604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81605       };
81606     } catch (Dali::DaliException e) {
81607       {
81608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81609       };
81610     } catch (...) {
81611       {
81612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81613       };
81614     }
81615   }
81616
81617   jresult = (void *)result;
81618   return jresult;
81619 }
81620
81621
81622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
81623   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81624
81625   arg1 = (Dali::Toolkit::TableView *)jarg1;
81626   {
81627     try {
81628       delete arg1;
81629     } catch (std::out_of_range& e) {
81630       {
81631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81632       };
81633     } catch (std::exception& e) {
81634       {
81635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81636       };
81637     } catch (Dali::DaliException e) {
81638       {
81639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81640       };
81641     } catch (...) {
81642       {
81643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81644       };
81645     }
81646   }
81647
81648 }
81649
81650
81651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
81652   void * jresult ;
81653   unsigned int arg1 ;
81654   unsigned int arg2 ;
81655   Dali::Toolkit::TableView result;
81656
81657   arg1 = (unsigned int)jarg1;
81658   arg2 = (unsigned int)jarg2;
81659   {
81660     try {
81661       result = Dali::Toolkit::TableView::New(arg1,arg2);
81662     } catch (std::out_of_range& e) {
81663       {
81664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81665       };
81666     } catch (std::exception& e) {
81667       {
81668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81669       };
81670     } catch (Dali::DaliException e) {
81671       {
81672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81673       };
81674     } catch (...) {
81675       {
81676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81677       };
81678     }
81679   }
81680
81681   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
81682   return jresult;
81683 }
81684
81685
81686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
81687   void * jresult ;
81688   Dali::BaseHandle arg1 ;
81689   Dali::BaseHandle *argp1 ;
81690   Dali::Toolkit::TableView result;
81691
81692   argp1 = (Dali::BaseHandle *)jarg1;
81693   if (!argp1) {
81694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81695     return 0;
81696   }
81697   arg1 = *argp1;
81698   {
81699     try {
81700       result = Dali::Toolkit::TableView::DownCast(arg1);
81701     } catch (std::out_of_range& e) {
81702       {
81703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81704       };
81705     } catch (std::exception& e) {
81706       {
81707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81708       };
81709     } catch (Dali::DaliException e) {
81710       {
81711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81712       };
81713     } catch (...) {
81714       {
81715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81716       };
81717     }
81718   }
81719
81720   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
81721   return jresult;
81722 }
81723
81724
81725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
81726   unsigned int jresult ;
81727   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81728   Dali::Actor arg2 ;
81729   Dali::Toolkit::TableView::CellPosition arg3 ;
81730   Dali::Actor *argp2 ;
81731   Dali::Toolkit::TableView::CellPosition *argp3 ;
81732   bool result;
81733
81734   arg1 = (Dali::Toolkit::TableView *)jarg1;
81735   argp2 = (Dali::Actor *)jarg2;
81736   if (!argp2) {
81737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81738     return 0;
81739   }
81740   arg2 = *argp2;
81741   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
81742   if (!argp3) {
81743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81744     return 0;
81745   }
81746   arg3 = *argp3;
81747   {
81748     try {
81749       result = (bool)(arg1)->AddChild(arg2,arg3);
81750     } catch (std::out_of_range& e) {
81751       {
81752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81753       };
81754     } catch (std::exception& e) {
81755       {
81756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81757       };
81758     } catch (Dali::DaliException e) {
81759       {
81760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81761       };
81762     } catch (...) {
81763       {
81764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81765       };
81766     }
81767   }
81768
81769   jresult = result;
81770   return jresult;
81771 }
81772
81773
81774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
81775   void * jresult ;
81776   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81777   Dali::Toolkit::TableView::CellPosition arg2 ;
81778   Dali::Toolkit::TableView::CellPosition *argp2 ;
81779   Dali::Actor result;
81780
81781   arg1 = (Dali::Toolkit::TableView *)jarg1;
81782   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
81783   if (!argp2) {
81784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81785     return 0;
81786   }
81787   arg2 = *argp2;
81788   {
81789     try {
81790       result = (arg1)->GetChildAt(arg2);
81791     } catch (std::out_of_range& e) {
81792       {
81793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81794       };
81795     } catch (std::exception& e) {
81796       {
81797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81798       };
81799     } catch (Dali::DaliException e) {
81800       {
81801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81802       };
81803     } catch (...) {
81804       {
81805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81806       };
81807     }
81808   }
81809
81810   jresult = new Dali::Actor((const Dali::Actor &)result);
81811   return jresult;
81812 }
81813
81814
81815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
81816   void * jresult ;
81817   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81818   Dali::Toolkit::TableView::CellPosition arg2 ;
81819   Dali::Toolkit::TableView::CellPosition *argp2 ;
81820   Dali::Actor result;
81821
81822   arg1 = (Dali::Toolkit::TableView *)jarg1;
81823   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
81824   if (!argp2) {
81825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81826     return 0;
81827   }
81828   arg2 = *argp2;
81829   {
81830     try {
81831       result = (arg1)->RemoveChildAt(arg2);
81832     } catch (std::out_of_range& e) {
81833       {
81834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81835       };
81836     } catch (std::exception& e) {
81837       {
81838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81839       };
81840     } catch (Dali::DaliException e) {
81841       {
81842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81843       };
81844     } catch (...) {
81845       {
81846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81847       };
81848     }
81849   }
81850
81851   jresult = new Dali::Actor((const Dali::Actor &)result);
81852   return jresult;
81853 }
81854
81855
81856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
81857   unsigned int jresult ;
81858   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81859   Dali::Actor arg2 ;
81860   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
81861   Dali::Actor *argp2 ;
81862   bool result;
81863
81864   arg1 = (Dali::Toolkit::TableView *)jarg1;
81865   argp2 = (Dali::Actor *)jarg2;
81866   if (!argp2) {
81867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81868     return 0;
81869   }
81870   arg2 = *argp2;
81871   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
81872   if (!arg3) {
81873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
81874     return 0;
81875   }
81876   {
81877     try {
81878       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
81879     } catch (std::out_of_range& e) {
81880       {
81881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81882       };
81883     } catch (std::exception& e) {
81884       {
81885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81886       };
81887     } catch (Dali::DaliException e) {
81888       {
81889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81890       };
81891     } catch (...) {
81892       {
81893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81894       };
81895     }
81896   }
81897
81898   jresult = result;
81899   return jresult;
81900 }
81901
81902
81903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
81904   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81905   unsigned int arg2 ;
81906
81907   arg1 = (Dali::Toolkit::TableView *)jarg1;
81908   arg2 = (unsigned int)jarg2;
81909   {
81910     try {
81911       (arg1)->InsertRow(arg2);
81912     } catch (std::out_of_range& e) {
81913       {
81914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81915       };
81916     } catch (std::exception& e) {
81917       {
81918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81919       };
81920     } catch (Dali::DaliException e) {
81921       {
81922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81923       };
81924     } catch (...) {
81925       {
81926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81927       };
81928     }
81929   }
81930
81931 }
81932
81933
81934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
81935   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81936   unsigned int arg2 ;
81937
81938   arg1 = (Dali::Toolkit::TableView *)jarg1;
81939   arg2 = (unsigned int)jarg2;
81940   {
81941     try {
81942       (arg1)->DeleteRow(arg2);
81943     } catch (std::out_of_range& e) {
81944       {
81945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81946       };
81947     } catch (std::exception& e) {
81948       {
81949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81950       };
81951     } catch (Dali::DaliException e) {
81952       {
81953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81954       };
81955     } catch (...) {
81956       {
81957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81958       };
81959     }
81960   }
81961
81962 }
81963
81964
81965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
81966   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81967   unsigned int arg2 ;
81968   std::vector< Dali::Actor > *arg3 = 0 ;
81969
81970   arg1 = (Dali::Toolkit::TableView *)jarg1;
81971   arg2 = (unsigned int)jarg2;
81972   arg3 = (std::vector< Dali::Actor > *)jarg3;
81973   if (!arg3) {
81974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
81975     return ;
81976   }
81977   {
81978     try {
81979       (arg1)->DeleteRow(arg2,*arg3);
81980     } catch (std::out_of_range& e) {
81981       {
81982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81983       };
81984     } catch (std::exception& e) {
81985       {
81986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81987       };
81988     } catch (Dali::DaliException e) {
81989       {
81990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81991       };
81992     } catch (...) {
81993       {
81994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81995       };
81996     }
81997   }
81998
81999 }
82000
82001
82002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
82003   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82004   unsigned int arg2 ;
82005
82006   arg1 = (Dali::Toolkit::TableView *)jarg1;
82007   arg2 = (unsigned int)jarg2;
82008   {
82009     try {
82010       (arg1)->InsertColumn(arg2);
82011     } catch (std::out_of_range& e) {
82012       {
82013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82014       };
82015     } catch (std::exception& e) {
82016       {
82017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82018       };
82019     } catch (Dali::DaliException e) {
82020       {
82021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82022       };
82023     } catch (...) {
82024       {
82025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82026       };
82027     }
82028   }
82029
82030 }
82031
82032
82033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
82034   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82035   unsigned int arg2 ;
82036
82037   arg1 = (Dali::Toolkit::TableView *)jarg1;
82038   arg2 = (unsigned int)jarg2;
82039   {
82040     try {
82041       (arg1)->DeleteColumn(arg2);
82042     } catch (std::out_of_range& e) {
82043       {
82044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82045       };
82046     } catch (std::exception& e) {
82047       {
82048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82049       };
82050     } catch (Dali::DaliException e) {
82051       {
82052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82053       };
82054     } catch (...) {
82055       {
82056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82057       };
82058     }
82059   }
82060
82061 }
82062
82063
82064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
82065   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82066   unsigned int arg2 ;
82067   std::vector< Dali::Actor > *arg3 = 0 ;
82068
82069   arg1 = (Dali::Toolkit::TableView *)jarg1;
82070   arg2 = (unsigned int)jarg2;
82071   arg3 = (std::vector< Dali::Actor > *)jarg3;
82072   if (!arg3) {
82073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82074     return ;
82075   }
82076   {
82077     try {
82078       (arg1)->DeleteColumn(arg2,*arg3);
82079     } catch (std::out_of_range& e) {
82080       {
82081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82082       };
82083     } catch (std::exception& e) {
82084       {
82085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82086       };
82087     } catch (Dali::DaliException e) {
82088       {
82089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82090       };
82091     } catch (...) {
82092       {
82093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82094       };
82095     }
82096   }
82097
82098 }
82099
82100
82101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
82102   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82103   unsigned int arg2 ;
82104   unsigned int arg3 ;
82105
82106   arg1 = (Dali::Toolkit::TableView *)jarg1;
82107   arg2 = (unsigned int)jarg2;
82108   arg3 = (unsigned int)jarg3;
82109   {
82110     try {
82111       (arg1)->Resize(arg2,arg3);
82112     } catch (std::out_of_range& e) {
82113       {
82114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82115       };
82116     } catch (std::exception& e) {
82117       {
82118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82119       };
82120     } catch (Dali::DaliException e) {
82121       {
82122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82123       };
82124     } catch (...) {
82125       {
82126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82127       };
82128     }
82129   }
82130
82131 }
82132
82133
82134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
82135   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82136   unsigned int arg2 ;
82137   unsigned int arg3 ;
82138   std::vector< Dali::Actor > *arg4 = 0 ;
82139
82140   arg1 = (Dali::Toolkit::TableView *)jarg1;
82141   arg2 = (unsigned int)jarg2;
82142   arg3 = (unsigned int)jarg3;
82143   arg4 = (std::vector< Dali::Actor > *)jarg4;
82144   if (!arg4) {
82145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82146     return ;
82147   }
82148   {
82149     try {
82150       (arg1)->Resize(arg2,arg3,*arg4);
82151     } catch (std::out_of_range& e) {
82152       {
82153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82154       };
82155     } catch (std::exception& e) {
82156       {
82157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82158       };
82159     } catch (Dali::DaliException e) {
82160       {
82161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82162       };
82163     } catch (...) {
82164       {
82165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82166       };
82167     }
82168   }
82169
82170 }
82171
82172
82173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
82174   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82175   Dali::Size arg2 ;
82176   Dali::Size *argp2 ;
82177
82178   arg1 = (Dali::Toolkit::TableView *)jarg1;
82179   argp2 = (Dali::Size *)jarg2;
82180   if (!argp2) {
82181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
82182     return ;
82183   }
82184   arg2 = *argp2;
82185   {
82186     try {
82187       (arg1)->SetCellPadding(arg2);
82188     } catch (std::out_of_range& e) {
82189       {
82190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82191       };
82192     } catch (std::exception& e) {
82193       {
82194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82195       };
82196     } catch (Dali::DaliException e) {
82197       {
82198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82199       };
82200     } catch (...) {
82201       {
82202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82203       };
82204     }
82205   }
82206
82207 }
82208
82209
82210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
82211   void * jresult ;
82212   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82213   Dali::Size result;
82214
82215   arg1 = (Dali::Toolkit::TableView *)jarg1;
82216   {
82217     try {
82218       result = (arg1)->GetCellPadding();
82219     } catch (std::out_of_range& e) {
82220       {
82221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82222       };
82223     } catch (std::exception& e) {
82224       {
82225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82226       };
82227     } catch (Dali::DaliException e) {
82228       {
82229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82230       };
82231     } catch (...) {
82232       {
82233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82234       };
82235     }
82236   }
82237
82238   jresult = new Dali::Size((const Dali::Size &)result);
82239   return jresult;
82240 }
82241
82242
82243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
82244   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82245   unsigned int arg2 ;
82246
82247   arg1 = (Dali::Toolkit::TableView *)jarg1;
82248   arg2 = (unsigned int)jarg2;
82249   {
82250     try {
82251       (arg1)->SetFitHeight(arg2);
82252     } catch (std::out_of_range& e) {
82253       {
82254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82255       };
82256     } catch (std::exception& e) {
82257       {
82258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82259       };
82260     } catch (Dali::DaliException e) {
82261       {
82262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82263       };
82264     } catch (...) {
82265       {
82266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82267       };
82268     }
82269   }
82270
82271 }
82272
82273
82274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
82275   unsigned int jresult ;
82276   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82277   unsigned int arg2 ;
82278   bool result;
82279
82280   arg1 = (Dali::Toolkit::TableView *)jarg1;
82281   arg2 = (unsigned int)jarg2;
82282   {
82283     try {
82284       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
82285     } catch (std::out_of_range& e) {
82286       {
82287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82288       };
82289     } catch (std::exception& e) {
82290       {
82291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82292       };
82293     } catch (Dali::DaliException e) {
82294       {
82295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82296       };
82297     } catch (...) {
82298       {
82299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82300       };
82301     }
82302   }
82303
82304   jresult = result;
82305   return jresult;
82306 }
82307
82308
82309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
82310   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82311   unsigned int arg2 ;
82312
82313   arg1 = (Dali::Toolkit::TableView *)jarg1;
82314   arg2 = (unsigned int)jarg2;
82315   {
82316     try {
82317       (arg1)->SetFitWidth(arg2);
82318     } catch (std::out_of_range& e) {
82319       {
82320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82321       };
82322     } catch (std::exception& e) {
82323       {
82324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82325       };
82326     } catch (Dali::DaliException e) {
82327       {
82328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82329       };
82330     } catch (...) {
82331       {
82332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82333       };
82334     }
82335   }
82336
82337 }
82338
82339
82340 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
82341   unsigned int jresult ;
82342   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82343   unsigned int arg2 ;
82344   bool result;
82345
82346   arg1 = (Dali::Toolkit::TableView *)jarg1;
82347   arg2 = (unsigned int)jarg2;
82348   {
82349     try {
82350       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
82351     } catch (std::out_of_range& e) {
82352       {
82353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82354       };
82355     } catch (std::exception& e) {
82356       {
82357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82358       };
82359     } catch (Dali::DaliException e) {
82360       {
82361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82362       };
82363     } catch (...) {
82364       {
82365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82366       };
82367     }
82368   }
82369
82370   jresult = result;
82371   return jresult;
82372 }
82373
82374
82375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
82376   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82377   unsigned int arg2 ;
82378   float arg3 ;
82379
82380   arg1 = (Dali::Toolkit::TableView *)jarg1;
82381   arg2 = (unsigned int)jarg2;
82382   arg3 = (float)jarg3;
82383   {
82384     try {
82385       (arg1)->SetFixedHeight(arg2,arg3);
82386     } catch (std::out_of_range& e) {
82387       {
82388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82389       };
82390     } catch (std::exception& e) {
82391       {
82392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82393       };
82394     } catch (Dali::DaliException e) {
82395       {
82396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82397       };
82398     } catch (...) {
82399       {
82400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82401       };
82402     }
82403   }
82404
82405 }
82406
82407
82408 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
82409   float jresult ;
82410   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82411   unsigned int arg2 ;
82412   float result;
82413
82414   arg1 = (Dali::Toolkit::TableView *)jarg1;
82415   arg2 = (unsigned int)jarg2;
82416   {
82417     try {
82418       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
82419     } catch (std::out_of_range& e) {
82420       {
82421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82422       };
82423     } catch (std::exception& e) {
82424       {
82425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82426       };
82427     } catch (Dali::DaliException e) {
82428       {
82429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82430       };
82431     } catch (...) {
82432       {
82433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82434       };
82435     }
82436   }
82437
82438   jresult = result;
82439   return jresult;
82440 }
82441
82442
82443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
82444   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82445   unsigned int arg2 ;
82446   float arg3 ;
82447
82448   arg1 = (Dali::Toolkit::TableView *)jarg1;
82449   arg2 = (unsigned int)jarg2;
82450   arg3 = (float)jarg3;
82451   {
82452     try {
82453       (arg1)->SetRelativeHeight(arg2,arg3);
82454     } catch (std::out_of_range& e) {
82455       {
82456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82457       };
82458     } catch (std::exception& e) {
82459       {
82460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82461       };
82462     } catch (Dali::DaliException e) {
82463       {
82464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82465       };
82466     } catch (...) {
82467       {
82468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82469       };
82470     }
82471   }
82472
82473 }
82474
82475
82476 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
82477   float jresult ;
82478   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82479   unsigned int arg2 ;
82480   float result;
82481
82482   arg1 = (Dali::Toolkit::TableView *)jarg1;
82483   arg2 = (unsigned int)jarg2;
82484   {
82485     try {
82486       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
82487     } catch (std::out_of_range& e) {
82488       {
82489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82490       };
82491     } catch (std::exception& e) {
82492       {
82493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82494       };
82495     } catch (Dali::DaliException e) {
82496       {
82497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82498       };
82499     } catch (...) {
82500       {
82501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82502       };
82503     }
82504   }
82505
82506   jresult = result;
82507   return jresult;
82508 }
82509
82510
82511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
82512   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82513   unsigned int arg2 ;
82514   float arg3 ;
82515
82516   arg1 = (Dali::Toolkit::TableView *)jarg1;
82517   arg2 = (unsigned int)jarg2;
82518   arg3 = (float)jarg3;
82519   {
82520     try {
82521       (arg1)->SetFixedWidth(arg2,arg3);
82522     } catch (std::out_of_range& e) {
82523       {
82524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82525       };
82526     } catch (std::exception& e) {
82527       {
82528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82529       };
82530     } catch (Dali::DaliException e) {
82531       {
82532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82533       };
82534     } catch (...) {
82535       {
82536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82537       };
82538     }
82539   }
82540
82541 }
82542
82543
82544 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
82545   float jresult ;
82546   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82547   unsigned int arg2 ;
82548   float result;
82549
82550   arg1 = (Dali::Toolkit::TableView *)jarg1;
82551   arg2 = (unsigned int)jarg2;
82552   {
82553     try {
82554       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
82555     } catch (std::out_of_range& e) {
82556       {
82557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82558       };
82559     } catch (std::exception& e) {
82560       {
82561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82562       };
82563     } catch (Dali::DaliException e) {
82564       {
82565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82566       };
82567     } catch (...) {
82568       {
82569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82570       };
82571     }
82572   }
82573
82574   jresult = result;
82575   return jresult;
82576 }
82577
82578
82579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
82580   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82581   unsigned int arg2 ;
82582   float arg3 ;
82583
82584   arg1 = (Dali::Toolkit::TableView *)jarg1;
82585   arg2 = (unsigned int)jarg2;
82586   arg3 = (float)jarg3;
82587   {
82588     try {
82589       (arg1)->SetRelativeWidth(arg2,arg3);
82590     } catch (std::out_of_range& e) {
82591       {
82592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82593       };
82594     } catch (std::exception& e) {
82595       {
82596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82597       };
82598     } catch (Dali::DaliException e) {
82599       {
82600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82601       };
82602     } catch (...) {
82603       {
82604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82605       };
82606     }
82607   }
82608
82609 }
82610
82611
82612 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
82613   float jresult ;
82614   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82615   unsigned int arg2 ;
82616   float result;
82617
82618   arg1 = (Dali::Toolkit::TableView *)jarg1;
82619   arg2 = (unsigned int)jarg2;
82620   {
82621     try {
82622       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
82623     } catch (std::out_of_range& e) {
82624       {
82625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82626       };
82627     } catch (std::exception& e) {
82628       {
82629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82630       };
82631     } catch (Dali::DaliException e) {
82632       {
82633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82634       };
82635     } catch (...) {
82636       {
82637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82638       };
82639     }
82640   }
82641
82642   jresult = result;
82643   return jresult;
82644 }
82645
82646
82647 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
82648   unsigned int jresult ;
82649   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82650   unsigned int result;
82651
82652   arg1 = (Dali::Toolkit::TableView *)jarg1;
82653   {
82654     try {
82655       result = (unsigned int)(arg1)->GetRows();
82656     } catch (std::out_of_range& e) {
82657       {
82658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82659       };
82660     } catch (std::exception& e) {
82661       {
82662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82663       };
82664     } catch (Dali::DaliException e) {
82665       {
82666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82667       };
82668     } catch (...) {
82669       {
82670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82671       };
82672     }
82673   }
82674
82675   jresult = result;
82676   return jresult;
82677 }
82678
82679
82680 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
82681   unsigned int jresult ;
82682   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82683   unsigned int result;
82684
82685   arg1 = (Dali::Toolkit::TableView *)jarg1;
82686   {
82687     try {
82688       result = (unsigned int)(arg1)->GetColumns();
82689     } catch (std::out_of_range& e) {
82690       {
82691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82692       };
82693     } catch (std::exception& e) {
82694       {
82695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82696       };
82697     } catch (Dali::DaliException e) {
82698       {
82699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82700       };
82701     } catch (...) {
82702       {
82703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82704       };
82705     }
82706   }
82707
82708   jresult = result;
82709   return jresult;
82710 }
82711
82712
82713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
82714   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82715   Dali::Toolkit::TableView::CellPosition arg2 ;
82716   Dali::HorizontalAlignment::Type arg3 ;
82717   Dali::VerticalAlignment::Type arg4 ;
82718   Dali::Toolkit::TableView::CellPosition *argp2 ;
82719
82720   arg1 = (Dali::Toolkit::TableView *)jarg1;
82721   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82722   if (!argp2) {
82723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82724     return ;
82725   }
82726   arg2 = *argp2;
82727   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
82728   arg4 = (Dali::VerticalAlignment::Type)jarg4;
82729   {
82730     try {
82731       (arg1)->SetCellAlignment(arg2,arg3,arg4);
82732     } catch (std::out_of_range& e) {
82733       {
82734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82735       };
82736     } catch (std::exception& e) {
82737       {
82738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82739       };
82740     } catch (Dali::DaliException e) {
82741       {
82742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82743       };
82744     } catch (...) {
82745       {
82746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82747       };
82748     }
82749   }
82750
82751 }
82752
82753
82754 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
82755   unsigned int jresult ;
82756   unsigned int result;
82757
82758   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
82759   jresult = result;
82760   return jresult;
82761 }
82762
82763
82764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
82765   int jresult ;
82766   int result;
82767
82768   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
82769   jresult = (int)result;
82770   return jresult;
82771 }
82772
82773
82774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
82775   int jresult ;
82776   int result;
82777
82778   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
82779   jresult = (int)result;
82780   return jresult;
82781 }
82782
82783
82784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
82785   int jresult ;
82786   int result;
82787
82788   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
82789   jresult = (int)result;
82790   return jresult;
82791 }
82792
82793
82794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
82795   int jresult ;
82796   int result;
82797
82798   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
82799   jresult = (int)result;
82800   return jresult;
82801 }
82802
82803
82804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
82805   int jresult ;
82806   int result;
82807
82808   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
82809   jresult = (int)result;
82810   return jresult;
82811 }
82812
82813
82814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
82815   int jresult ;
82816   int result;
82817
82818   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
82819   jresult = (int)result;
82820   return jresult;
82821 }
82822
82823
82824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
82825   int jresult ;
82826   int result;
82827
82828   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
82829   jresult = (int)result;
82830   return jresult;
82831 }
82832
82833
82834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
82835   int jresult ;
82836   int result;
82837
82838   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
82839   jresult = (int)result;
82840   return jresult;
82841 }
82842
82843
82844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
82845   int jresult ;
82846   int result;
82847
82848   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
82849   jresult = (int)result;
82850   return jresult;
82851 }
82852
82853
82854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
82855   int jresult ;
82856   int result;
82857
82858   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
82859   jresult = (int)result;
82860   return jresult;
82861 }
82862
82863
82864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
82865   int jresult ;
82866   int result;
82867
82868   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
82869   jresult = (int)result;
82870   return jresult;
82871 }
82872
82873
82874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
82875   int jresult ;
82876   int result;
82877
82878   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
82879   jresult = (int)result;
82880   return jresult;
82881 }
82882
82883
82884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
82885   int jresult ;
82886   int result;
82887
82888   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
82889   jresult = (int)result;
82890   return jresult;
82891 }
82892
82893
82894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
82895   int jresult ;
82896   int result;
82897
82898   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
82899   jresult = (int)result;
82900   return jresult;
82901 }
82902
82903
82904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
82905   int jresult ;
82906   int result;
82907
82908   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
82909   jresult = (int)result;
82910   return jresult;
82911 }
82912
82913
82914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
82915   int jresult ;
82916   int result;
82917
82918   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
82919   jresult = (int)result;
82920   return jresult;
82921 }
82922
82923
82924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
82925   int jresult ;
82926   int result;
82927
82928   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
82929   jresult = (int)result;
82930   return jresult;
82931 }
82932
82933
82934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
82935   int jresult ;
82936   int result;
82937
82938   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
82939   jresult = (int)result;
82940   return jresult;
82941 }
82942
82943
82944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
82945   int jresult ;
82946   int result;
82947
82948   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
82949   jresult = (int)result;
82950   return jresult;
82951 }
82952
82953
82954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
82955   void * jresult ;
82956   Dali::Toolkit::TextLabel::Property *result = 0 ;
82957
82958   {
82959     try {
82960       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
82961     } catch (std::out_of_range& e) {
82962       {
82963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82964       };
82965     } catch (std::exception& e) {
82966       {
82967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82968       };
82969     } catch (Dali::DaliException e) {
82970       {
82971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82972       };
82973     } catch (...) {
82974       {
82975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82976       };
82977     }
82978   }
82979
82980   jresult = (void *)result;
82981   return jresult;
82982 }
82983
82984
82985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
82986   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
82987
82988   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
82989   {
82990     try {
82991       delete arg1;
82992     } catch (std::out_of_range& e) {
82993       {
82994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82995       };
82996     } catch (std::exception& e) {
82997       {
82998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82999       };
83000     } catch (Dali::DaliException e) {
83001       {
83002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83003       };
83004     } catch (...) {
83005       {
83006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83007       };
83008     }
83009   }
83010
83011 }
83012
83013
83014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
83015   void * jresult ;
83016   Dali::Toolkit::TextLabel result;
83017
83018   {
83019     try {
83020       result = Dali::Toolkit::TextLabel::New();
83021     } catch (std::out_of_range& e) {
83022       {
83023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83024       };
83025     } catch (std::exception& e) {
83026       {
83027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83028       };
83029     } catch (Dali::DaliException e) {
83030       {
83031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83032       };
83033     } catch (...) {
83034       {
83035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83036       };
83037     }
83038   }
83039
83040   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83041   return jresult;
83042 }
83043
83044
83045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
83046   void * jresult ;
83047   std::string *arg1 = 0 ;
83048   Dali::Toolkit::TextLabel result;
83049
83050   if (!jarg1) {
83051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83052     return 0;
83053   }
83054   std::string arg1_str(jarg1);
83055   arg1 = &arg1_str;
83056   {
83057     try {
83058       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
83059     } catch (std::out_of_range& e) {
83060       {
83061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83062       };
83063     } catch (std::exception& e) {
83064       {
83065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83066       };
83067     } catch (Dali::DaliException e) {
83068       {
83069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83070       };
83071     } catch (...) {
83072       {
83073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83074       };
83075     }
83076   }
83077
83078   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83079
83080   //argout typemap for const std::string&
83081
83082   return jresult;
83083 }
83084
83085
83086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
83087   void * jresult ;
83088   Dali::Toolkit::TextLabel *result = 0 ;
83089
83090   {
83091     try {
83092       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
83093     } catch (std::out_of_range& e) {
83094       {
83095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83096       };
83097     } catch (std::exception& e) {
83098       {
83099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83100       };
83101     } catch (Dali::DaliException e) {
83102       {
83103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83104       };
83105     } catch (...) {
83106       {
83107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83108       };
83109     }
83110   }
83111
83112   jresult = (void *)result;
83113   return jresult;
83114 }
83115
83116
83117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
83118   void * jresult ;
83119   Dali::Toolkit::TextLabel *arg1 = 0 ;
83120   Dali::Toolkit::TextLabel *result = 0 ;
83121
83122   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83123   if (!arg1) {
83124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
83125     return 0;
83126   }
83127   {
83128     try {
83129       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
83130     } catch (std::out_of_range& e) {
83131       {
83132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83133       };
83134     } catch (std::exception& e) {
83135       {
83136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83137       };
83138     } catch (Dali::DaliException e) {
83139       {
83140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83141       };
83142     } catch (...) {
83143       {
83144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83145       };
83146     }
83147   }
83148
83149   jresult = (void *)result;
83150   return jresult;
83151 }
83152
83153
83154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
83155   void * jresult ;
83156   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
83157   Dali::Toolkit::TextLabel *arg2 = 0 ;
83158   Dali::Toolkit::TextLabel *result = 0 ;
83159
83160   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83161   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
83162   if (!arg2) {
83163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
83164     return 0;
83165   }
83166   {
83167     try {
83168       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
83169     } catch (std::out_of_range& e) {
83170       {
83171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83172       };
83173     } catch (std::exception& e) {
83174       {
83175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83176       };
83177     } catch (Dali::DaliException e) {
83178       {
83179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83180       };
83181     } catch (...) {
83182       {
83183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83184       };
83185     }
83186   }
83187
83188   jresult = (void *)result;
83189   return jresult;
83190 }
83191
83192
83193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
83194   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
83195
83196   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83197   {
83198     try {
83199       delete arg1;
83200     } catch (std::out_of_range& e) {
83201       {
83202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83203       };
83204     } catch (std::exception& e) {
83205       {
83206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83207       };
83208     } catch (Dali::DaliException e) {
83209       {
83210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83211       };
83212     } catch (...) {
83213       {
83214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83215       };
83216     }
83217   }
83218
83219 }
83220
83221
83222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
83223   void * jresult ;
83224   Dali::BaseHandle arg1 ;
83225   Dali::BaseHandle *argp1 ;
83226   Dali::Toolkit::TextLabel result;
83227
83228   argp1 = (Dali::BaseHandle *)jarg1;
83229   if (!argp1) {
83230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83231     return 0;
83232   }
83233   arg1 = *argp1;
83234   {
83235     try {
83236       result = Dali::Toolkit::TextLabel::DownCast(arg1);
83237     } catch (std::out_of_range& e) {
83238       {
83239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83240       };
83241     } catch (std::exception& e) {
83242       {
83243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83244       };
83245     } catch (Dali::DaliException e) {
83246       {
83247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83248       };
83249     } catch (...) {
83250       {
83251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83252       };
83253     }
83254   }
83255
83256   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83257   return jresult;
83258 }
83259
83260
83261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
83262   void * jresult ;
83263   Dali::Toolkit::AccessibilityManager *result = 0 ;
83264
83265   {
83266     try {
83267       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
83268     } catch (std::out_of_range& e) {
83269       {
83270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83271       };
83272     } catch (std::exception& e) {
83273       {
83274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83275       };
83276     } catch (Dali::DaliException e) {
83277       {
83278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83279       };
83280     } catch (...) {
83281       {
83282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83283       };
83284     }
83285   }
83286
83287   jresult = (void *)result;
83288   return jresult;
83289 }
83290
83291
83292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
83293   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83294
83295   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83296   {
83297     try {
83298       delete arg1;
83299     } catch (std::out_of_range& e) {
83300       {
83301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83302       };
83303     } catch (std::exception& e) {
83304       {
83305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83306       };
83307     } catch (Dali::DaliException e) {
83308       {
83309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83310       };
83311     } catch (...) {
83312       {
83313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83314       };
83315     }
83316   }
83317
83318 }
83319
83320
83321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
83322   void * jresult ;
83323   Dali::Toolkit::AccessibilityManager result;
83324
83325   {
83326     try {
83327       result = Dali::Toolkit::AccessibilityManager::Get();
83328     } catch (std::out_of_range& e) {
83329       {
83330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83331       };
83332     } catch (std::exception& e) {
83333       {
83334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83335       };
83336     } catch (Dali::DaliException e) {
83337       {
83338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83339       };
83340     } catch (...) {
83341       {
83342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83343       };
83344     }
83345   }
83346
83347   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
83348   return jresult;
83349 }
83350
83351
83352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
83353   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83354   Dali::Actor arg2 ;
83355   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
83356   std::string *arg4 = 0 ;
83357   Dali::Actor *argp2 ;
83358
83359   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83360   argp2 = (Dali::Actor *)jarg2;
83361   if (!argp2) {
83362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83363     return ;
83364   }
83365   arg2 = *argp2;
83366   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
83367   if (!jarg4) {
83368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83369     return ;
83370   }
83371   std::string arg4_str(jarg4);
83372   arg4 = &arg4_str;
83373   {
83374     try {
83375       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
83376     } catch (std::out_of_range& e) {
83377       {
83378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83379       };
83380     } catch (std::exception& e) {
83381       {
83382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83383       };
83384     } catch (Dali::DaliException e) {
83385       {
83386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83387       };
83388     } catch (...) {
83389       {
83390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83391       };
83392     }
83393   }
83394
83395
83396   //argout typemap for const std::string&
83397
83398 }
83399
83400
83401 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
83402   char * jresult ;
83403   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83404   Dali::Actor arg2 ;
83405   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
83406   Dali::Actor *argp2 ;
83407   std::string result;
83408
83409   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83410   argp2 = (Dali::Actor *)jarg2;
83411   if (!argp2) {
83412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83413     return 0;
83414   }
83415   arg2 = *argp2;
83416   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
83417   {
83418     try {
83419       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
83420     } catch (std::out_of_range& e) {
83421       {
83422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83423       };
83424     } catch (std::exception& e) {
83425       {
83426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83427       };
83428     } catch (Dali::DaliException e) {
83429       {
83430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83431       };
83432     } catch (...) {
83433       {
83434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83435       };
83436     }
83437   }
83438
83439   jresult = SWIG_csharp_string_callback((&result)->c_str());
83440   return jresult;
83441 }
83442
83443
83444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
83445   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83446   Dali::Actor arg2 ;
83447   unsigned int arg3 ;
83448   Dali::Actor *argp2 ;
83449
83450   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83451   argp2 = (Dali::Actor *)jarg2;
83452   if (!argp2) {
83453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83454     return ;
83455   }
83456   arg2 = *argp2;
83457   arg3 = (unsigned int)jarg3;
83458   {
83459     try {
83460       (arg1)->SetFocusOrder(arg2,arg3);
83461     } catch (std::out_of_range& e) {
83462       {
83463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83464       };
83465     } catch (std::exception& e) {
83466       {
83467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83468       };
83469     } catch (Dali::DaliException e) {
83470       {
83471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83472       };
83473     } catch (...) {
83474       {
83475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83476       };
83477     }
83478   }
83479
83480 }
83481
83482
83483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
83484   unsigned int jresult ;
83485   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83486   Dali::Actor arg2 ;
83487   Dali::Actor *argp2 ;
83488   unsigned int result;
83489
83490   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83491   argp2 = (Dali::Actor *)jarg2;
83492   if (!argp2) {
83493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83494     return 0;
83495   }
83496   arg2 = *argp2;
83497   {
83498     try {
83499       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
83500     } catch (std::out_of_range& e) {
83501       {
83502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83503       };
83504     } catch (std::exception& e) {
83505       {
83506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83507       };
83508     } catch (Dali::DaliException e) {
83509       {
83510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83511       };
83512     } catch (...) {
83513       {
83514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83515       };
83516     }
83517   }
83518
83519   jresult = result;
83520   return jresult;
83521 }
83522
83523
83524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
83525   unsigned int jresult ;
83526   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83527   unsigned int result;
83528
83529   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83530   {
83531     try {
83532       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
83533     } catch (std::out_of_range& e) {
83534       {
83535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83536       };
83537     } catch (std::exception& e) {
83538       {
83539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83540       };
83541     } catch (Dali::DaliException e) {
83542       {
83543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83544       };
83545     } catch (...) {
83546       {
83547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83548       };
83549     }
83550   }
83551
83552   jresult = result;
83553   return jresult;
83554 }
83555
83556
83557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
83558   void * jresult ;
83559   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83560   unsigned int arg2 ;
83561   Dali::Actor result;
83562
83563   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83564   arg2 = (unsigned int)jarg2;
83565   {
83566     try {
83567       result = (arg1)->GetActorByFocusOrder(arg2);
83568     } catch (std::out_of_range& e) {
83569       {
83570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83571       };
83572     } catch (std::exception& e) {
83573       {
83574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83575       };
83576     } catch (Dali::DaliException e) {
83577       {
83578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83579       };
83580     } catch (...) {
83581       {
83582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83583       };
83584     }
83585   }
83586
83587   jresult = new Dali::Actor((const Dali::Actor &)result);
83588   return jresult;
83589 }
83590
83591
83592 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
83593   unsigned int jresult ;
83594   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83595   Dali::Actor arg2 ;
83596   Dali::Actor *argp2 ;
83597   bool result;
83598
83599   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83600   argp2 = (Dali::Actor *)jarg2;
83601   if (!argp2) {
83602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83603     return 0;
83604   }
83605   arg2 = *argp2;
83606   {
83607     try {
83608       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
83609     } catch (std::out_of_range& e) {
83610       {
83611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83612       };
83613     } catch (std::exception& e) {
83614       {
83615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83616       };
83617     } catch (Dali::DaliException e) {
83618       {
83619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83620       };
83621     } catch (...) {
83622       {
83623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83624       };
83625     }
83626   }
83627
83628   jresult = result;
83629   return jresult;
83630 }
83631
83632
83633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
83634   void * jresult ;
83635   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83636   Dali::Actor result;
83637
83638   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83639   {
83640     try {
83641       result = (arg1)->GetCurrentFocusActor();
83642     } catch (std::out_of_range& e) {
83643       {
83644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83645       };
83646     } catch (std::exception& e) {
83647       {
83648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83649       };
83650     } catch (Dali::DaliException e) {
83651       {
83652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83653       };
83654     } catch (...) {
83655       {
83656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83657       };
83658     }
83659   }
83660
83661   jresult = new Dali::Actor((const Dali::Actor &)result);
83662   return jresult;
83663 }
83664
83665
83666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
83667   void * jresult ;
83668   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83669   Dali::Actor result;
83670
83671   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83672   {
83673     try {
83674       result = (arg1)->GetCurrentFocusGroup();
83675     } catch (std::out_of_range& e) {
83676       {
83677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83678       };
83679     } catch (std::exception& e) {
83680       {
83681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83682       };
83683     } catch (Dali::DaliException e) {
83684       {
83685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83686       };
83687     } catch (...) {
83688       {
83689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83690       };
83691     }
83692   }
83693
83694   jresult = new Dali::Actor((const Dali::Actor &)result);
83695   return jresult;
83696 }
83697
83698
83699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
83700   unsigned int jresult ;
83701   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83702   unsigned int result;
83703
83704   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83705   {
83706     try {
83707       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
83708     } catch (std::out_of_range& e) {
83709       {
83710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83711       };
83712     } catch (std::exception& e) {
83713       {
83714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83715       };
83716     } catch (Dali::DaliException e) {
83717       {
83718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83719       };
83720     } catch (...) {
83721       {
83722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83723       };
83724     }
83725   }
83726
83727   jresult = result;
83728   return jresult;
83729 }
83730
83731
83732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
83733   unsigned int jresult ;
83734   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83735   bool result;
83736
83737   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83738   {
83739     try {
83740       result = (bool)(arg1)->MoveFocusForward();
83741     } catch (std::out_of_range& e) {
83742       {
83743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83744       };
83745     } catch (std::exception& e) {
83746       {
83747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83748       };
83749     } catch (Dali::DaliException e) {
83750       {
83751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83752       };
83753     } catch (...) {
83754       {
83755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83756       };
83757     }
83758   }
83759
83760   jresult = result;
83761   return jresult;
83762 }
83763
83764
83765 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
83766   unsigned int jresult ;
83767   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83768   bool result;
83769
83770   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83771   {
83772     try {
83773       result = (bool)(arg1)->MoveFocusBackward();
83774     } catch (std::out_of_range& e) {
83775       {
83776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83777       };
83778     } catch (std::exception& e) {
83779       {
83780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83781       };
83782     } catch (Dali::DaliException e) {
83783       {
83784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83785       };
83786     } catch (...) {
83787       {
83788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83789       };
83790     }
83791   }
83792
83793   jresult = result;
83794   return jresult;
83795 }
83796
83797
83798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
83799   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83800
83801   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83802   {
83803     try {
83804       (arg1)->ClearFocus();
83805     } catch (std::out_of_range& e) {
83806       {
83807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83808       };
83809     } catch (std::exception& e) {
83810       {
83811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83812       };
83813     } catch (Dali::DaliException e) {
83814       {
83815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83816       };
83817     } catch (...) {
83818       {
83819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83820       };
83821     }
83822   }
83823
83824 }
83825
83826
83827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
83828   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83829
83830   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83831   {
83832     try {
83833       (arg1)->Reset();
83834     } catch (std::out_of_range& e) {
83835       {
83836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83837       };
83838     } catch (std::exception& e) {
83839       {
83840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83841       };
83842     } catch (Dali::DaliException e) {
83843       {
83844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83845       };
83846     } catch (...) {
83847       {
83848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83849       };
83850     }
83851   }
83852
83853 }
83854
83855
83856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
83857   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83858   Dali::Actor arg2 ;
83859   bool arg3 ;
83860   Dali::Actor *argp2 ;
83861
83862   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83863   argp2 = (Dali::Actor *)jarg2;
83864   if (!argp2) {
83865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83866     return ;
83867   }
83868   arg2 = *argp2;
83869   arg3 = jarg3 ? true : false;
83870   {
83871     try {
83872       (arg1)->SetFocusGroup(arg2,arg3);
83873     } catch (std::out_of_range& e) {
83874       {
83875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83876       };
83877     } catch (std::exception& e) {
83878       {
83879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83880       };
83881     } catch (Dali::DaliException e) {
83882       {
83883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83884       };
83885     } catch (...) {
83886       {
83887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83888       };
83889     }
83890   }
83891
83892 }
83893
83894
83895 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
83896   unsigned int jresult ;
83897   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83898   Dali::Actor arg2 ;
83899   Dali::Actor *argp2 ;
83900   bool result;
83901
83902   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83903   argp2 = (Dali::Actor *)jarg2;
83904   if (!argp2) {
83905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83906     return 0;
83907   }
83908   arg2 = *argp2;
83909   {
83910     try {
83911       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
83912     } catch (std::out_of_range& e) {
83913       {
83914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83915       };
83916     } catch (std::exception& e) {
83917       {
83918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83919       };
83920     } catch (Dali::DaliException e) {
83921       {
83922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83923       };
83924     } catch (...) {
83925       {
83926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83927       };
83928     }
83929   }
83930
83931   jresult = result;
83932   return jresult;
83933 }
83934
83935
83936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
83937   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83938   bool arg2 ;
83939
83940   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83941   arg2 = jarg2 ? true : false;
83942   {
83943     try {
83944       (arg1)->SetGroupMode(arg2);
83945     } catch (std::out_of_range& e) {
83946       {
83947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83948       };
83949     } catch (std::exception& e) {
83950       {
83951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83952       };
83953     } catch (Dali::DaliException e) {
83954       {
83955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83956       };
83957     } catch (...) {
83958       {
83959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83960       };
83961     }
83962   }
83963
83964 }
83965
83966
83967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
83968   unsigned int jresult ;
83969   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83970   bool result;
83971
83972   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83973   {
83974     try {
83975       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
83976     } catch (std::out_of_range& e) {
83977       {
83978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83979       };
83980     } catch (std::exception& e) {
83981       {
83982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83983       };
83984     } catch (Dali::DaliException e) {
83985       {
83986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83987       };
83988     } catch (...) {
83989       {
83990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83991       };
83992     }
83993   }
83994
83995   jresult = result;
83996   return jresult;
83997 }
83998
83999
84000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
84001   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84002   bool arg2 ;
84003
84004   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84005   arg2 = jarg2 ? true : false;
84006   {
84007     try {
84008       (arg1)->SetWrapMode(arg2);
84009     } catch (std::out_of_range& e) {
84010       {
84011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84012       };
84013     } catch (std::exception& e) {
84014       {
84015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84016       };
84017     } catch (Dali::DaliException e) {
84018       {
84019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84020       };
84021     } catch (...) {
84022       {
84023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84024       };
84025     }
84026   }
84027
84028 }
84029
84030
84031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
84032   unsigned int jresult ;
84033   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84034   bool result;
84035
84036   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84037   {
84038     try {
84039       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
84040     } catch (std::out_of_range& e) {
84041       {
84042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84043       };
84044     } catch (std::exception& e) {
84045       {
84046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84047       };
84048     } catch (Dali::DaliException e) {
84049       {
84050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84051       };
84052     } catch (...) {
84053       {
84054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84055       };
84056     }
84057   }
84058
84059   jresult = result;
84060   return jresult;
84061 }
84062
84063
84064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
84065   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84066   Dali::Actor arg2 ;
84067   Dali::Actor *argp2 ;
84068
84069   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84070   argp2 = (Dali::Actor *)jarg2;
84071   if (!argp2) {
84072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84073     return ;
84074   }
84075   arg2 = *argp2;
84076   {
84077     try {
84078       (arg1)->SetFocusIndicatorActor(arg2);
84079     } catch (std::out_of_range& e) {
84080       {
84081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84082       };
84083     } catch (std::exception& e) {
84084       {
84085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84086       };
84087     } catch (Dali::DaliException e) {
84088       {
84089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84090       };
84091     } catch (...) {
84092       {
84093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84094       };
84095     }
84096   }
84097
84098 }
84099
84100
84101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
84102   void * jresult ;
84103   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84104   Dali::Actor result;
84105
84106   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84107   {
84108     try {
84109       result = (arg1)->GetFocusIndicatorActor();
84110     } catch (std::out_of_range& e) {
84111       {
84112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84113       };
84114     } catch (std::exception& e) {
84115       {
84116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84117       };
84118     } catch (Dali::DaliException e) {
84119       {
84120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84121       };
84122     } catch (...) {
84123       {
84124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84125       };
84126     }
84127   }
84128
84129   jresult = new Dali::Actor((const Dali::Actor &)result);
84130   return jresult;
84131 }
84132
84133
84134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
84135   void * jresult ;
84136   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84137   Dali::Actor arg2 ;
84138   Dali::Actor *argp2 ;
84139   Dali::Actor result;
84140
84141   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84142   argp2 = (Dali::Actor *)jarg2;
84143   if (!argp2) {
84144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84145     return 0;
84146   }
84147   arg2 = *argp2;
84148   {
84149     try {
84150       result = (arg1)->GetFocusGroup(arg2);
84151     } catch (std::out_of_range& e) {
84152       {
84153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84154       };
84155     } catch (std::exception& e) {
84156       {
84157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84158       };
84159     } catch (Dali::DaliException e) {
84160       {
84161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84162       };
84163     } catch (...) {
84164       {
84165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84166       };
84167     }
84168   }
84169
84170   jresult = new Dali::Actor((const Dali::Actor &)result);
84171   return jresult;
84172 }
84173
84174
84175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
84176   void * jresult ;
84177   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84178   Dali::Vector2 result;
84179
84180   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84181   {
84182     try {
84183       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
84184     } catch (std::out_of_range& e) {
84185       {
84186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84187       };
84188     } catch (std::exception& e) {
84189       {
84190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84191       };
84192     } catch (Dali::DaliException e) {
84193       {
84194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84195       };
84196     } catch (...) {
84197       {
84198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84199       };
84200     }
84201   }
84202
84203   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
84204   return jresult;
84205 }
84206
84207
84208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
84209   void * jresult ;
84210   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84211   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
84212
84213   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84214   {
84215     try {
84216       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
84217     } catch (std::out_of_range& e) {
84218       {
84219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84220       };
84221     } catch (std::exception& e) {
84222       {
84223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84224       };
84225     } catch (Dali::DaliException e) {
84226       {
84227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84228       };
84229     } catch (...) {
84230       {
84231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84232       };
84233     }
84234   }
84235
84236   jresult = (void *)result;
84237   return jresult;
84238 }
84239
84240
84241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
84242   void * jresult ;
84243   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84244   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
84245
84246   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84247   {
84248     try {
84249       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
84250     } catch (std::out_of_range& e) {
84251       {
84252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84253       };
84254     } catch (std::exception& e) {
84255       {
84256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84257       };
84258     } catch (Dali::DaliException e) {
84259       {
84260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84261       };
84262     } catch (...) {
84263       {
84264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84265       };
84266     }
84267   }
84268
84269   jresult = (void *)result;
84270   return jresult;
84271 }
84272
84273
84274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
84275   void * jresult ;
84276   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84277   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
84278
84279   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84280   {
84281     try {
84282       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
84283     } catch (std::out_of_range& e) {
84284       {
84285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84286       };
84287     } catch (std::exception& e) {
84288       {
84289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84290       };
84291     } catch (Dali::DaliException e) {
84292       {
84293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84294       };
84295     } catch (...) {
84296       {
84297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84298       };
84299     }
84300   }
84301
84302   jresult = (void *)result;
84303   return jresult;
84304 }
84305
84306
84307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
84308   void * jresult ;
84309   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84310   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84311
84312   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84313   {
84314     try {
84315       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
84316     } catch (std::out_of_range& e) {
84317       {
84318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84319       };
84320     } catch (std::exception& e) {
84321       {
84322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84323       };
84324     } catch (Dali::DaliException e) {
84325       {
84326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84327       };
84328     } catch (...) {
84329       {
84330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84331       };
84332     }
84333   }
84334
84335   jresult = (void *)result;
84336   return jresult;
84337 }
84338
84339
84340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
84341   void * jresult ;
84342   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84343   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84344
84345   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84346   {
84347     try {
84348       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
84349     } catch (std::out_of_range& e) {
84350       {
84351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84352       };
84353     } catch (std::exception& e) {
84354       {
84355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84356       };
84357     } catch (Dali::DaliException e) {
84358       {
84359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84360       };
84361     } catch (...) {
84362       {
84363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84364       };
84365     }
84366   }
84367
84368   jresult = (void *)result;
84369   return jresult;
84370 }
84371
84372
84373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
84374   void * jresult ;
84375   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84376   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84377
84378   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84379   {
84380     try {
84381       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
84382     } catch (std::out_of_range& e) {
84383       {
84384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84385       };
84386     } catch (std::exception& e) {
84387       {
84388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84389       };
84390     } catch (Dali::DaliException e) {
84391       {
84392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84393       };
84394     } catch (...) {
84395       {
84396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84397       };
84398     }
84399   }
84400
84401   jresult = (void *)result;
84402   return jresult;
84403 }
84404
84405
84406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
84407   void * jresult ;
84408   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84409   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84410
84411   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84412   {
84413     try {
84414       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
84415     } catch (std::out_of_range& e) {
84416       {
84417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84418       };
84419     } catch (std::exception& e) {
84420       {
84421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84422       };
84423     } catch (Dali::DaliException e) {
84424       {
84425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84426       };
84427     } catch (...) {
84428       {
84429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84430       };
84431     }
84432   }
84433
84434   jresult = (void *)result;
84435   return jresult;
84436 }
84437
84438
84439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
84440   void * jresult ;
84441   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84442   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84443
84444   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84445   {
84446     try {
84447       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
84448     } catch (std::out_of_range& e) {
84449       {
84450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84451       };
84452     } catch (std::exception& e) {
84453       {
84454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84455       };
84456     } catch (Dali::DaliException e) {
84457       {
84458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84459       };
84460     } catch (...) {
84461       {
84462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84463       };
84464     }
84465   }
84466
84467   jresult = (void *)result;
84468   return jresult;
84469 }
84470
84471
84472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
84473   void * jresult ;
84474   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84475   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84476
84477   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84478   {
84479     try {
84480       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
84481     } catch (std::out_of_range& e) {
84482       {
84483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84484       };
84485     } catch (std::exception& e) {
84486       {
84487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84488       };
84489     } catch (Dali::DaliException e) {
84490       {
84491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84492       };
84493     } catch (...) {
84494       {
84495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84496       };
84497     }
84498   }
84499
84500   jresult = (void *)result;
84501   return jresult;
84502 }
84503
84504
84505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
84506   void * jresult ;
84507   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84508   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84509
84510   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84511   {
84512     try {
84513       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
84514     } catch (std::out_of_range& e) {
84515       {
84516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84517       };
84518     } catch (std::exception& e) {
84519       {
84520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84521       };
84522     } catch (Dali::DaliException e) {
84523       {
84524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84525       };
84526     } catch (...) {
84527       {
84528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84529       };
84530     }
84531   }
84532
84533   jresult = (void *)result;
84534   return jresult;
84535 }
84536
84537
84538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
84539   void * jresult ;
84540   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84541   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84542
84543   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84544   {
84545     try {
84546       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
84547     } catch (std::out_of_range& e) {
84548       {
84549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84550       };
84551     } catch (std::exception& e) {
84552       {
84553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84554       };
84555     } catch (Dali::DaliException e) {
84556       {
84557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84558       };
84559     } catch (...) {
84560       {
84561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84562       };
84563     }
84564   }
84565
84566   jresult = (void *)result;
84567   return jresult;
84568 }
84569
84570
84571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
84572   void * jresult ;
84573   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84574   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84575
84576   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84577   {
84578     try {
84579       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
84580     } catch (std::out_of_range& e) {
84581       {
84582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84583       };
84584     } catch (std::exception& e) {
84585       {
84586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84587       };
84588     } catch (Dali::DaliException e) {
84589       {
84590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84591       };
84592     } catch (...) {
84593       {
84594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84595       };
84596     }
84597   }
84598
84599   jresult = (void *)result;
84600   return jresult;
84601 }
84602
84603
84604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
84605   void * jresult ;
84606   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84607   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84608
84609   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84610   {
84611     try {
84612       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
84613     } catch (std::out_of_range& e) {
84614       {
84615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84616       };
84617     } catch (std::exception& e) {
84618       {
84619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84620       };
84621     } catch (Dali::DaliException e) {
84622       {
84623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84624       };
84625     } catch (...) {
84626       {
84627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84628       };
84629     }
84630   }
84631
84632   jresult = (void *)result;
84633   return jresult;
84634 }
84635
84636
84637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
84638   void * jresult ;
84639   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84640   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84641
84642   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84643   {
84644     try {
84645       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
84646     } catch (std::out_of_range& e) {
84647       {
84648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84649       };
84650     } catch (std::exception& e) {
84651       {
84652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84653       };
84654     } catch (Dali::DaliException e) {
84655       {
84656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84657       };
84658     } catch (...) {
84659       {
84660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84661       };
84662     }
84663   }
84664
84665   jresult = (void *)result;
84666   return jresult;
84667 }
84668
84669
84670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
84671   void * jresult ;
84672   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84673   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84674
84675   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84676   {
84677     try {
84678       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
84679     } catch (std::out_of_range& e) {
84680       {
84681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84682       };
84683     } catch (std::exception& e) {
84684       {
84685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84686       };
84687     } catch (Dali::DaliException e) {
84688       {
84689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84690       };
84691     } catch (...) {
84692       {
84693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84694       };
84695     }
84696   }
84697
84698   jresult = (void *)result;
84699   return jresult;
84700 }
84701
84702
84703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
84704   void * jresult ;
84705   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84706   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84707
84708   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84709   {
84710     try {
84711       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
84712     } catch (std::out_of_range& e) {
84713       {
84714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84715       };
84716     } catch (std::exception& e) {
84717       {
84718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84719       };
84720     } catch (Dali::DaliException e) {
84721       {
84722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84723       };
84724     } catch (...) {
84725       {
84726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84727       };
84728     }
84729   }
84730
84731   jresult = (void *)result;
84732   return jresult;
84733 }
84734
84735
84736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
84737   void * jresult ;
84738   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84739   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84740
84741   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84742   {
84743     try {
84744       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
84745     } catch (std::out_of_range& e) {
84746       {
84747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84748       };
84749     } catch (std::exception& e) {
84750       {
84751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84752       };
84753     } catch (Dali::DaliException e) {
84754       {
84755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84756       };
84757     } catch (...) {
84758       {
84759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84760       };
84761     }
84762   }
84763
84764   jresult = (void *)result;
84765   return jresult;
84766 }
84767
84768
84769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
84770   void * jresult ;
84771   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84772   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84773
84774   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84775   {
84776     try {
84777       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
84778     } catch (std::out_of_range& e) {
84779       {
84780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84781       };
84782     } catch (std::exception& e) {
84783       {
84784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84785       };
84786     } catch (Dali::DaliException e) {
84787       {
84788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84789       };
84790     } catch (...) {
84791       {
84792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84793       };
84794     }
84795   }
84796
84797   jresult = (void *)result;
84798   return jresult;
84799 }
84800
84801
84802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
84803   void * jresult ;
84804   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84805   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84806
84807   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84808   {
84809     try {
84810       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
84811     } catch (std::out_of_range& e) {
84812       {
84813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84814       };
84815     } catch (std::exception& e) {
84816       {
84817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84818       };
84819     } catch (Dali::DaliException e) {
84820       {
84821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84822       };
84823     } catch (...) {
84824       {
84825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84826       };
84827     }
84828   }
84829
84830   jresult = (void *)result;
84831   return jresult;
84832 }
84833
84834
84835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
84836   void * jresult ;
84837   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84838   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84839
84840   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84841   {
84842     try {
84843       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
84844     } catch (std::out_of_range& e) {
84845       {
84846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84847       };
84848     } catch (std::exception& e) {
84849       {
84850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84851       };
84852     } catch (Dali::DaliException e) {
84853       {
84854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84855       };
84856     } catch (...) {
84857       {
84858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84859       };
84860     }
84861   }
84862
84863   jresult = (void *)result;
84864   return jresult;
84865 }
84866
84867
84868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
84869   void * jresult ;
84870   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84871   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84872
84873   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84874   {
84875     try {
84876       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
84877     } catch (std::out_of_range& e) {
84878       {
84879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84880       };
84881     } catch (std::exception& e) {
84882       {
84883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84884       };
84885     } catch (Dali::DaliException e) {
84886       {
84887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84888       };
84889     } catch (...) {
84890       {
84891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84892       };
84893     }
84894   }
84895
84896   jresult = (void *)result;
84897   return jresult;
84898 }
84899
84900
84901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
84902   void * jresult ;
84903   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84904   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84905
84906   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84907   {
84908     try {
84909       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
84910     } catch (std::out_of_range& e) {
84911       {
84912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84913       };
84914     } catch (std::exception& e) {
84915       {
84916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84917       };
84918     } catch (Dali::DaliException e) {
84919       {
84920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84921       };
84922     } catch (...) {
84923       {
84924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84925       };
84926     }
84927   }
84928
84929   jresult = (void *)result;
84930   return jresult;
84931 }
84932
84933
84934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
84935   void * jresult ;
84936   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84937   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84938
84939   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84940   {
84941     try {
84942       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
84943     } catch (std::out_of_range& e) {
84944       {
84945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84946       };
84947     } catch (std::exception& e) {
84948       {
84949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84950       };
84951     } catch (Dali::DaliException e) {
84952       {
84953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84954       };
84955     } catch (...) {
84956       {
84957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84958       };
84959     }
84960   }
84961
84962   jresult = (void *)result;
84963   return jresult;
84964 }
84965
84966
84967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
84968   void * jresult ;
84969   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84970   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84971
84972   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84973   {
84974     try {
84975       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
84976     } catch (std::out_of_range& e) {
84977       {
84978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84979       };
84980     } catch (std::exception& e) {
84981       {
84982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84983       };
84984     } catch (Dali::DaliException e) {
84985       {
84986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84987       };
84988     } catch (...) {
84989       {
84990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84991       };
84992     }
84993   }
84994
84995   jresult = (void *)result;
84996   return jresult;
84997 }
84998
84999
85000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
85001   void * jresult ;
85002   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85003   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85004
85005   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85006   {
85007     try {
85008       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
85009     } catch (std::out_of_range& e) {
85010       {
85011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85012       };
85013     } catch (std::exception& e) {
85014       {
85015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85016       };
85017     } catch (Dali::DaliException e) {
85018       {
85019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85020       };
85021     } catch (...) {
85022       {
85023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85024       };
85025     }
85026   }
85027
85028   jresult = (void *)result;
85029   return jresult;
85030 }
85031
85032
85033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
85034   void * jresult ;
85035   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85036   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85037
85038   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85039   {
85040     try {
85041       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
85042     } catch (std::out_of_range& e) {
85043       {
85044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85045       };
85046     } catch (std::exception& e) {
85047       {
85048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85049       };
85050     } catch (Dali::DaliException e) {
85051       {
85052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85053       };
85054     } catch (...) {
85055       {
85056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85057       };
85058     }
85059   }
85060
85061   jresult = (void *)result;
85062   return jresult;
85063 }
85064
85065
85066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
85067   void * jresult ;
85068   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85069   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85070
85071   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85072   {
85073     try {
85074       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
85075     } catch (std::out_of_range& e) {
85076       {
85077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85078       };
85079     } catch (std::exception& e) {
85080       {
85081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85082       };
85083     } catch (Dali::DaliException e) {
85084       {
85085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85086       };
85087     } catch (...) {
85088       {
85089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85090       };
85091     }
85092   }
85093
85094   jresult = (void *)result;
85095   return jresult;
85096 }
85097
85098
85099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
85100   void * jresult ;
85101   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85102   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85103
85104   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85105   {
85106     try {
85107       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
85108     } catch (std::out_of_range& e) {
85109       {
85110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85111       };
85112     } catch (std::exception& e) {
85113       {
85114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85115       };
85116     } catch (Dali::DaliException e) {
85117       {
85118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85119       };
85120     } catch (...) {
85121       {
85122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85123       };
85124     }
85125   }
85126
85127   jresult = (void *)result;
85128   return jresult;
85129 }
85130
85131
85132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
85133   void * jresult ;
85134   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85135   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85136
85137   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85138   {
85139     try {
85140       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
85141     } catch (std::out_of_range& e) {
85142       {
85143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85144       };
85145     } catch (std::exception& e) {
85146       {
85147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85148       };
85149     } catch (Dali::DaliException e) {
85150       {
85151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85152       };
85153     } catch (...) {
85154       {
85155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85156       };
85157     }
85158   }
85159
85160   jresult = (void *)result;
85161   return jresult;
85162 }
85163
85164
85165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
85166   void * jresult ;
85167   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85168   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
85169
85170   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85171   {
85172     try {
85173       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
85174     } catch (std::out_of_range& e) {
85175       {
85176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85177       };
85178     } catch (std::exception& e) {
85179       {
85180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85181       };
85182     } catch (Dali::DaliException e) {
85183       {
85184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85185       };
85186     } catch (...) {
85187       {
85188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85189       };
85190     }
85191   }
85192
85193   jresult = (void *)result;
85194   return jresult;
85195 }
85196
85197
85198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
85199   void * jresult ;
85200   Dali::Toolkit::StyleManager *result = 0 ;
85201
85202   {
85203     try {
85204       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
85205     } catch (std::out_of_range& e) {
85206       {
85207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85208       };
85209     } catch (std::exception& e) {
85210       {
85211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85212       };
85213     } catch (Dali::DaliException e) {
85214       {
85215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85216       };
85217     } catch (...) {
85218       {
85219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85220       };
85221     }
85222   }
85223
85224   jresult = (void *)result;
85225   return jresult;
85226 }
85227
85228
85229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
85230   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85231
85232   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85233   {
85234     try {
85235       delete arg1;
85236     } catch (std::out_of_range& e) {
85237       {
85238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85239       };
85240     } catch (std::exception& e) {
85241       {
85242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85243       };
85244     } catch (Dali::DaliException e) {
85245       {
85246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85247       };
85248     } catch (...) {
85249       {
85250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85251       };
85252     }
85253   }
85254
85255 }
85256
85257
85258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
85259   void * jresult ;
85260   Dali::Toolkit::StyleManager result;
85261
85262   {
85263     try {
85264       result = Dali::Toolkit::StyleManager::Get();
85265     } catch (std::out_of_range& e) {
85266       {
85267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85268       };
85269     } catch (std::exception& e) {
85270       {
85271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85272       };
85273     } catch (Dali::DaliException e) {
85274       {
85275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85276       };
85277     } catch (...) {
85278       {
85279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85280       };
85281     }
85282   }
85283
85284   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
85285   return jresult;
85286 }
85287
85288
85289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
85290   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85291   std::string *arg2 = 0 ;
85292
85293   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85294   if (!jarg2) {
85295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85296     return ;
85297   }
85298   std::string arg2_str(jarg2);
85299   arg2 = &arg2_str;
85300   {
85301     try {
85302       (arg1)->ApplyTheme((std::string const &)*arg2);
85303     } catch (std::out_of_range& e) {
85304       {
85305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85306       };
85307     } catch (std::exception& e) {
85308       {
85309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85310       };
85311     } catch (Dali::DaliException e) {
85312       {
85313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85314       };
85315     } catch (...) {
85316       {
85317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85318       };
85319     }
85320   }
85321
85322
85323   //argout typemap for const std::string&
85324
85325 }
85326
85327
85328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
85329   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85330
85331   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85332   {
85333     try {
85334       (arg1)->ApplyDefaultTheme();
85335     } catch (std::out_of_range& e) {
85336       {
85337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85338       };
85339     } catch (std::exception& e) {
85340       {
85341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85342       };
85343     } catch (Dali::DaliException e) {
85344       {
85345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85346       };
85347     } catch (...) {
85348       {
85349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85350       };
85351     }
85352   }
85353
85354 }
85355
85356
85357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
85358   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85359   std::string *arg2 = 0 ;
85360   Dali::Property::Value *arg3 = 0 ;
85361
85362   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85363   if (!jarg2) {
85364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85365     return ;
85366   }
85367   std::string arg2_str(jarg2);
85368   arg2 = &arg2_str;
85369   arg3 = (Dali::Property::Value *)jarg3;
85370   if (!arg3) {
85371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
85372     return ;
85373   }
85374   {
85375     try {
85376       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
85377     } catch (std::out_of_range& e) {
85378       {
85379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85380       };
85381     } catch (std::exception& e) {
85382       {
85383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85384       };
85385     } catch (Dali::DaliException e) {
85386       {
85387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85388       };
85389     } catch (...) {
85390       {
85391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85392       };
85393     }
85394   }
85395
85396
85397   //argout typemap for const std::string&
85398
85399 }
85400
85401
85402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
85403   unsigned int jresult ;
85404   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85405   std::string *arg2 = 0 ;
85406   Dali::Property::Value *arg3 = 0 ;
85407   bool result;
85408
85409   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85410   if (!jarg2) {
85411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85412     return 0;
85413   }
85414   std::string arg2_str(jarg2);
85415   arg2 = &arg2_str;
85416   arg3 = (Dali::Property::Value *)jarg3;
85417   if (!arg3) {
85418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
85419     return 0;
85420   }
85421   {
85422     try {
85423       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
85424     } catch (std::out_of_range& e) {
85425       {
85426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85427       };
85428     } catch (std::exception& e) {
85429       {
85430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85431       };
85432     } catch (Dali::DaliException e) {
85433       {
85434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85435       };
85436     } catch (...) {
85437       {
85438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85439       };
85440     }
85441   }
85442
85443   jresult = result;
85444
85445   //argout typemap for const std::string&
85446
85447   return jresult;
85448 }
85449
85450
85451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
85452   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85453   Dali::Toolkit::Control arg2 ;
85454   std::string *arg3 = 0 ;
85455   std::string *arg4 = 0 ;
85456   Dali::Toolkit::Control *argp2 ;
85457
85458   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85459   argp2 = (Dali::Toolkit::Control *)jarg2;
85460   if (!argp2) {
85461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
85462     return ;
85463   }
85464   arg2 = *argp2;
85465   if (!jarg3) {
85466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85467     return ;
85468   }
85469   std::string arg3_str(jarg3);
85470   arg3 = &arg3_str;
85471   if (!jarg4) {
85472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85473     return ;
85474   }
85475   std::string arg4_str(jarg4);
85476   arg4 = &arg4_str;
85477   {
85478     try {
85479       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
85480     } catch (std::out_of_range& e) {
85481       {
85482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85483       };
85484     } catch (std::exception& e) {
85485       {
85486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85487       };
85488     } catch (Dali::DaliException e) {
85489       {
85490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85491       };
85492     } catch (...) {
85493       {
85494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85495       };
85496     }
85497   }
85498
85499
85500   //argout typemap for const std::string&
85501
85502
85503   //argout typemap for const std::string&
85504
85505 }
85506
85507
85508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
85509   void * jresult ;
85510   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85511   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
85512
85513   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85514   {
85515     try {
85516       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
85517     } catch (std::out_of_range& e) {
85518       {
85519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85520       };
85521     } catch (std::exception& e) {
85522       {
85523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85524       };
85525     } catch (Dali::DaliException e) {
85526       {
85527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85528       };
85529     } catch (...) {
85530       {
85531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85532       };
85533     }
85534   }
85535
85536   jresult = (void *)result;
85537   return jresult;
85538 }
85539
85540
85541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
85542   int jresult ;
85543   int result;
85544
85545   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
85546   jresult = (int)result;
85547   return jresult;
85548 }
85549
85550
85551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
85552   int jresult ;
85553   int result;
85554
85555   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
85556   jresult = (int)result;
85557   return jresult;
85558 }
85559
85560
85561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
85562   int jresult ;
85563   int result;
85564
85565   result = (int)Dali::Toolkit::Slider::Property::VALUE;
85566   jresult = (int)result;
85567   return jresult;
85568 }
85569
85570
85571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
85572   int jresult ;
85573   int result;
85574
85575   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
85576   jresult = (int)result;
85577   return jresult;
85578 }
85579
85580
85581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
85582   int jresult ;
85583   int result;
85584
85585   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
85586   jresult = (int)result;
85587   return jresult;
85588 }
85589
85590
85591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
85592   int jresult ;
85593   int result;
85594
85595   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
85596   jresult = (int)result;
85597   return jresult;
85598 }
85599
85600
85601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
85602   int jresult ;
85603   int result;
85604
85605   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
85606   jresult = (int)result;
85607   return jresult;
85608 }
85609
85610
85611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
85612   int jresult ;
85613   int result;
85614
85615   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
85616   jresult = (int)result;
85617   return jresult;
85618 }
85619
85620
85621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
85622   int jresult ;
85623   int result;
85624
85625   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
85626   jresult = (int)result;
85627   return jresult;
85628 }
85629
85630
85631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
85632   int jresult ;
85633   int result;
85634
85635   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
85636   jresult = (int)result;
85637   return jresult;
85638 }
85639
85640
85641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
85642   int jresult ;
85643   int result;
85644
85645   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
85646   jresult = (int)result;
85647   return jresult;
85648 }
85649
85650
85651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
85652   int jresult ;
85653   int result;
85654
85655   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
85656   jresult = (int)result;
85657   return jresult;
85658 }
85659
85660
85661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
85662   int jresult ;
85663   int result;
85664
85665   result = (int)Dali::Toolkit::Slider::Property::MARKS;
85666   jresult = (int)result;
85667   return jresult;
85668 }
85669
85670
85671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
85672   int jresult ;
85673   int result;
85674
85675   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
85676   jresult = (int)result;
85677   return jresult;
85678 }
85679
85680
85681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
85682   int jresult ;
85683   int result;
85684
85685   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
85686   jresult = (int)result;
85687   return jresult;
85688 }
85689
85690
85691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
85692   void * jresult ;
85693   Dali::Toolkit::Slider::Property *result = 0 ;
85694
85695   {
85696     try {
85697       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
85698     } catch (std::out_of_range& e) {
85699       {
85700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85701       };
85702     } catch (std::exception& e) {
85703       {
85704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85705       };
85706     } catch (Dali::DaliException e) {
85707       {
85708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85709       };
85710     } catch (...) {
85711       {
85712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85713       };
85714     }
85715   }
85716
85717   jresult = (void *)result;
85718   return jresult;
85719 }
85720
85721
85722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
85723   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
85724
85725   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
85726   {
85727     try {
85728       delete arg1;
85729     } catch (std::out_of_range& e) {
85730       {
85731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85732       };
85733     } catch (std::exception& e) {
85734       {
85735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85736       };
85737     } catch (Dali::DaliException e) {
85738       {
85739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85740       };
85741     } catch (...) {
85742       {
85743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85744       };
85745     }
85746   }
85747
85748 }
85749
85750
85751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
85752   void * jresult ;
85753   Dali::Toolkit::Slider result;
85754
85755   {
85756     try {
85757       result = Dali::Toolkit::Slider::New();
85758     } catch (std::out_of_range& e) {
85759       {
85760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85761       };
85762     } catch (std::exception& e) {
85763       {
85764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85765       };
85766     } catch (Dali::DaliException e) {
85767       {
85768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85769       };
85770     } catch (...) {
85771       {
85772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85773       };
85774     }
85775   }
85776
85777   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
85778   return jresult;
85779 }
85780
85781
85782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
85783   void * jresult ;
85784   Dali::Toolkit::Slider *result = 0 ;
85785
85786   {
85787     try {
85788       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
85789     } catch (std::out_of_range& e) {
85790       {
85791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85792       };
85793     } catch (std::exception& e) {
85794       {
85795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85796       };
85797     } catch (Dali::DaliException e) {
85798       {
85799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85800       };
85801     } catch (...) {
85802       {
85803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85804       };
85805     }
85806   }
85807
85808   jresult = (void *)result;
85809   return jresult;
85810 }
85811
85812
85813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
85814   void * jresult ;
85815   Dali::Toolkit::Slider *arg1 = 0 ;
85816   Dali::Toolkit::Slider *result = 0 ;
85817
85818   arg1 = (Dali::Toolkit::Slider *)jarg1;
85819   if (!arg1) {
85820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
85821     return 0;
85822   }
85823   {
85824     try {
85825       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
85826     } catch (std::out_of_range& e) {
85827       {
85828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85829       };
85830     } catch (std::exception& e) {
85831       {
85832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85833       };
85834     } catch (Dali::DaliException e) {
85835       {
85836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85837       };
85838     } catch (...) {
85839       {
85840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85841       };
85842     }
85843   }
85844
85845   jresult = (void *)result;
85846   return jresult;
85847 }
85848
85849
85850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
85851   void * jresult ;
85852   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85853   Dali::Toolkit::Slider *arg2 = 0 ;
85854   Dali::Toolkit::Slider *result = 0 ;
85855
85856   arg1 = (Dali::Toolkit::Slider *)jarg1;
85857   arg2 = (Dali::Toolkit::Slider *)jarg2;
85858   if (!arg2) {
85859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
85860     return 0;
85861   }
85862   {
85863     try {
85864       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
85865     } catch (std::out_of_range& e) {
85866       {
85867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85868       };
85869     } catch (std::exception& e) {
85870       {
85871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85872       };
85873     } catch (Dali::DaliException e) {
85874       {
85875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85876       };
85877     } catch (...) {
85878       {
85879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85880       };
85881     }
85882   }
85883
85884   jresult = (void *)result;
85885   return jresult;
85886 }
85887
85888
85889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
85890   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85891
85892   arg1 = (Dali::Toolkit::Slider *)jarg1;
85893   {
85894     try {
85895       delete arg1;
85896     } catch (std::out_of_range& e) {
85897       {
85898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85899       };
85900     } catch (std::exception& e) {
85901       {
85902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85903       };
85904     } catch (Dali::DaliException e) {
85905       {
85906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85907       };
85908     } catch (...) {
85909       {
85910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85911       };
85912     }
85913   }
85914
85915 }
85916
85917
85918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
85919   void * jresult ;
85920   Dali::BaseHandle arg1 ;
85921   Dali::BaseHandle *argp1 ;
85922   Dali::Toolkit::Slider result;
85923
85924   argp1 = (Dali::BaseHandle *)jarg1;
85925   if (!argp1) {
85926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85927     return 0;
85928   }
85929   arg1 = *argp1;
85930   {
85931     try {
85932       result = Dali::Toolkit::Slider::DownCast(arg1);
85933     } catch (std::out_of_range& e) {
85934       {
85935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85936       };
85937     } catch (std::exception& e) {
85938       {
85939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85940       };
85941     } catch (Dali::DaliException e) {
85942       {
85943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85944       };
85945     } catch (...) {
85946       {
85947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85948       };
85949     }
85950   }
85951
85952   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
85953   return jresult;
85954 }
85955
85956
85957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
85958   void * jresult ;
85959   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85960   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
85961
85962   arg1 = (Dali::Toolkit::Slider *)jarg1;
85963   {
85964     try {
85965       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
85966     } catch (std::out_of_range& e) {
85967       {
85968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85969       };
85970     } catch (std::exception& e) {
85971       {
85972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85973       };
85974     } catch (Dali::DaliException e) {
85975       {
85976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85977       };
85978     } catch (...) {
85979       {
85980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85981       };
85982     }
85983   }
85984
85985   jresult = (void *)result;
85986   return jresult;
85987 }
85988
85989
85990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
85991   void * jresult ;
85992   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85993   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
85994
85995   arg1 = (Dali::Toolkit::Slider *)jarg1;
85996   {
85997     try {
85998       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
85999     } catch (std::out_of_range& e) {
86000       {
86001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86002       };
86003     } catch (std::exception& e) {
86004       {
86005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86006       };
86007     } catch (Dali::DaliException e) {
86008       {
86009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86010       };
86011     } catch (...) {
86012       {
86013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86014       };
86015     }
86016   }
86017
86018   jresult = (void *)result;
86019   return jresult;
86020 }
86021
86022
86023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
86024   void * jresult ;
86025   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86026   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
86027
86028   arg1 = (Dali::Toolkit::Slider *)jarg1;
86029   {
86030     try {
86031       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
86032     } catch (std::out_of_range& e) {
86033       {
86034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86035       };
86036     } catch (std::exception& e) {
86037       {
86038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86039       };
86040     } catch (Dali::DaliException e) {
86041       {
86042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86043       };
86044     } catch (...) {
86045       {
86046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86047       };
86048     }
86049   }
86050
86051   jresult = (void *)result;
86052   return jresult;
86053 }
86054
86055
86056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
86057   int jresult ;
86058   int result;
86059
86060   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
86061   jresult = (int)result;
86062   return jresult;
86063 }
86064
86065
86066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
86067   int jresult ;
86068   int result;
86069
86070   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
86071   jresult = (int)result;
86072   return jresult;
86073 }
86074
86075
86076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
86077   int jresult ;
86078   int result;
86079
86080   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
86081   jresult = (int)result;
86082   return jresult;
86083 }
86084
86085
86086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
86087   int jresult ;
86088   int result;
86089
86090   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
86091   jresult = (int)result;
86092   return jresult;
86093 }
86094
86095
86096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
86097   int result;
86098
86099   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
86100
86101   return result;
86102 }
86103
86104
86105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
86106   void * jresult ;
86107   Dali::Toolkit::VideoView::Property *result = 0 ;
86108
86109   {
86110     try {
86111       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
86112     } catch (std::out_of_range& e) {
86113       {
86114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86115       };
86116     } catch (std::exception& e) {
86117       {
86118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86119       };
86120     } catch (Dali::DaliException e) {
86121       {
86122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86123       };
86124     } catch (...) {
86125       {
86126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86127       };
86128     }
86129   }
86130
86131   jresult = (void *)result;
86132   return jresult;
86133 }
86134
86135
86136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
86137   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
86138
86139   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
86140   {
86141     try {
86142       delete arg1;
86143     } catch (std::out_of_range& e) {
86144       {
86145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86146       };
86147     } catch (std::exception& e) {
86148       {
86149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86150       };
86151     } catch (Dali::DaliException e) {
86152       {
86153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86154       };
86155     } catch (...) {
86156       {
86157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86158       };
86159     }
86160   }
86161
86162 }
86163
86164
86165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
86166   void * jresult ;
86167   Dali::Toolkit::VideoView result;
86168
86169   {
86170     try {
86171       result = Dali::Toolkit::VideoView::New();
86172     } catch (std::out_of_range& e) {
86173       {
86174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86175       };
86176     } catch (std::exception& e) {
86177       {
86178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86179       };
86180     } catch (Dali::DaliException e) {
86181       {
86182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86183       };
86184     } catch (...) {
86185       {
86186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86187       };
86188     }
86189   }
86190
86191   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86192   return jresult;
86193 }
86194
86195
86196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
86197   void * jresult ;
86198   std::string *arg1 = 0 ;
86199   Dali::Toolkit::VideoView result;
86200
86201   if (!jarg1) {
86202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86203     return 0;
86204   }
86205   std::string arg1_str(jarg1);
86206   arg1 = &arg1_str;
86207   {
86208     try {
86209       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
86210     } catch (std::out_of_range& e) {
86211       {
86212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86213       };
86214     } catch (std::exception& e) {
86215       {
86216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86217       };
86218     } catch (Dali::DaliException e) {
86219       {
86220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86221       };
86222     } catch (...) {
86223       {
86224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86225       };
86226     }
86227   }
86228
86229   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86230
86231   //argout typemap for const std::string&
86232
86233   return jresult;
86234 }
86235
86236
86237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
86238   void * jresult ;
86239   Dali::Toolkit::VideoView result;
86240   {
86241     try {
86242       result = Dali::Toolkit::VideoView::New(swCodec);
86243     } catch (std::out_of_range& e) {
86244       {
86245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86246       };
86247     } catch (std::exception& e) {
86248       {
86249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86250       };
86251     } catch (Dali::DaliException e) {
86252       {
86253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86254       };
86255     } catch (...) {
86256       {
86257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86258       };
86259     }
86260   }
86261
86262   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86263
86264   //argout typemap for const std::string&
86265
86266   return jresult;
86267 }
86268
86269
86270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
86271   void * jresult ;
86272   std::string *arg1 = 0 ;
86273   Dali::Toolkit::VideoView result;
86274
86275   if (!jarg1) {
86276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86277     return 0;
86278   }
86279   std::string arg1_str(jarg1);
86280   arg1 = &arg1_str;
86281   {
86282     try {
86283       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
86284     } catch (std::out_of_range& e) {
86285       {
86286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86287       };
86288     } catch (std::exception& e) {
86289       {
86290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86291       };
86292     } catch (Dali::DaliException e) {
86293       {
86294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86295       };
86296     } catch (...) {
86297       {
86298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86299       };
86300     }
86301   }
86302
86303   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86304
86305   //argout typemap for const std::string&
86306
86307   return jresult;
86308 }
86309
86310
86311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
86312   void * jresult ;
86313   Dali::Toolkit::VideoView *result = 0 ;
86314
86315   {
86316     try {
86317       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
86318     } catch (std::out_of_range& e) {
86319       {
86320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86321       };
86322     } catch (std::exception& e) {
86323       {
86324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86325       };
86326     } catch (Dali::DaliException e) {
86327       {
86328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86329       };
86330     } catch (...) {
86331       {
86332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86333       };
86334     }
86335   }
86336
86337   jresult = (void *)result;
86338   return jresult;
86339 }
86340
86341
86342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
86343   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86344
86345   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86346   {
86347     try {
86348       delete arg1;
86349     } catch (std::out_of_range& e) {
86350       {
86351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86352       };
86353     } catch (std::exception& e) {
86354       {
86355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86356       };
86357     } catch (Dali::DaliException e) {
86358       {
86359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86360       };
86361     } catch (...) {
86362       {
86363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86364       };
86365     }
86366   }
86367
86368 }
86369
86370
86371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
86372   void * jresult ;
86373   Dali::Toolkit::VideoView *arg1 = 0 ;
86374   Dali::Toolkit::VideoView *result = 0 ;
86375
86376   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86377   if (!arg1) {
86378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
86379     return 0;
86380   }
86381   {
86382     try {
86383       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
86384     } catch (std::out_of_range& e) {
86385       {
86386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86387       };
86388     } catch (std::exception& e) {
86389       {
86390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86391       };
86392     } catch (Dali::DaliException e) {
86393       {
86394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86395       };
86396     } catch (...) {
86397       {
86398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86399       };
86400     }
86401   }
86402
86403   jresult = (void *)result;
86404   return jresult;
86405 }
86406
86407
86408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
86409   void * jresult ;
86410   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86411   Dali::Toolkit::VideoView *arg2 = 0 ;
86412   Dali::Toolkit::VideoView *result = 0 ;
86413
86414   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86415   arg2 = (Dali::Toolkit::VideoView *)jarg2;
86416   if (!arg2) {
86417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
86418     return 0;
86419   }
86420   {
86421     try {
86422       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
86423     } catch (std::out_of_range& e) {
86424       {
86425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86426       };
86427     } catch (std::exception& e) {
86428       {
86429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86430       };
86431     } catch (Dali::DaliException e) {
86432       {
86433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86434       };
86435     } catch (...) {
86436       {
86437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86438       };
86439     }
86440   }
86441
86442   jresult = (void *)result;
86443   return jresult;
86444 }
86445
86446
86447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
86448   void * jresult ;
86449   Dali::BaseHandle arg1 ;
86450   Dali::BaseHandle *argp1 ;
86451   Dali::Toolkit::VideoView result;
86452
86453   argp1 = (Dali::BaseHandle *)jarg1;
86454   if (!argp1) {
86455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86456     return 0;
86457   }
86458   arg1 = *argp1;
86459   {
86460     try {
86461       result = Dali::Toolkit::VideoView::DownCast(arg1);
86462     } catch (std::out_of_range& e) {
86463       {
86464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86465       };
86466     } catch (std::exception& e) {
86467       {
86468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86469       };
86470     } catch (Dali::DaliException e) {
86471       {
86472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86473       };
86474     } catch (...) {
86475       {
86476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86477       };
86478     }
86479   }
86480
86481   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86482   return jresult;
86483 }
86484
86485
86486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
86487   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86488
86489   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86490   {
86491     try {
86492       (arg1)->Play();
86493     } catch (std::out_of_range& e) {
86494       {
86495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86496       };
86497     } catch (std::exception& e) {
86498       {
86499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86500       };
86501     } catch (Dali::DaliException e) {
86502       {
86503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86504       };
86505     } catch (...) {
86506       {
86507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86508       };
86509     }
86510   }
86511
86512 }
86513
86514
86515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
86516   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86517
86518   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86519   {
86520     try {
86521       (arg1)->Pause();
86522     } catch (std::out_of_range& e) {
86523       {
86524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86525       };
86526     } catch (std::exception& e) {
86527       {
86528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86529       };
86530     } catch (Dali::DaliException e) {
86531       {
86532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86533       };
86534     } catch (...) {
86535       {
86536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86537       };
86538     }
86539   }
86540
86541 }
86542
86543
86544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
86545   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86546
86547   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86548   {
86549     try {
86550       (arg1)->Stop();
86551     } catch (std::out_of_range& e) {
86552       {
86553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86554       };
86555     } catch (std::exception& e) {
86556       {
86557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86558       };
86559     } catch (Dali::DaliException e) {
86560       {
86561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86562       };
86563     } catch (...) {
86564       {
86565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86566       };
86567     }
86568   }
86569
86570 }
86571
86572
86573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
86574   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86575   int arg2 ;
86576
86577   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86578   arg2 = (int)jarg2;
86579   {
86580     try {
86581       (arg1)->Forward(arg2);
86582     } catch (std::out_of_range& e) {
86583       {
86584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86585       };
86586     } catch (std::exception& e) {
86587       {
86588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86589       };
86590     } catch (Dali::DaliException e) {
86591       {
86592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86593       };
86594     } catch (...) {
86595       {
86596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86597       };
86598     }
86599   }
86600
86601 }
86602
86603
86604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
86605   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86606   int arg2 ;
86607
86608   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86609   arg2 = (int)jarg2;
86610   {
86611     try {
86612       (arg1)->Backward(arg2);
86613     } catch (std::out_of_range& e) {
86614       {
86615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86616       };
86617     } catch (std::exception& e) {
86618       {
86619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86620       };
86621     } catch (Dali::DaliException e) {
86622       {
86623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86624       };
86625     } catch (...) {
86626       {
86627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86628       };
86629     }
86630   }
86631
86632 }
86633
86634
86635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
86636   void * jresult ;
86637   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86638   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
86639
86640   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86641   {
86642     try {
86643       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
86644     } catch (std::out_of_range& e) {
86645       {
86646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86647       };
86648     } catch (std::exception& e) {
86649       {
86650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86651       };
86652     } catch (Dali::DaliException e) {
86653       {
86654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86655       };
86656     } catch (...) {
86657       {
86658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86659       };
86660     }
86661   }
86662
86663   jresult = (void *)result;
86664   return jresult;
86665 }
86666
86667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
86668 {
86669   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
86670   if( arg1 == nullptr )
86671   {
86672     DALI_LOG_ERROR("VideoView is nullptr!");
86673     return nullptr;
86674   }
86675   void * ret = nullptr;
86676   {
86677     try{
86678
86679       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
86680       ret = Dali::AnyCast< void * >( result );
86681
86682     } catch (std::out_of_range& e) {
86683       {
86684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86685       };
86686     } catch (std::exception& e) {
86687       {
86688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86689       };
86690     } catch (Dali::DaliException e) {
86691       {
86692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86693       };
86694     } catch (...) {
86695       {
86696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86697       };
86698     }
86699   }
86700   return ret;
86701 }
86702
86703
86704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
86705   int jresult ;
86706   int result;
86707
86708   result = (int)Dali::Toolkit::Popup::Property::TITLE;
86709   jresult = (int)result;
86710   return jresult;
86711 }
86712
86713
86714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
86715   int jresult ;
86716   int result;
86717
86718   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
86719   jresult = (int)result;
86720   return jresult;
86721 }
86722
86723
86724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
86725   int jresult ;
86726   int result;
86727
86728   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
86729   jresult = (int)result;
86730   return jresult;
86731 }
86732
86733
86734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
86735   int jresult ;
86736   int result;
86737
86738   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
86739   jresult = (int)result;
86740   return jresult;
86741 }
86742
86743
86744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
86745   int jresult ;
86746   int result;
86747
86748   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
86749   jresult = (int)result;
86750   return jresult;
86751 }
86752
86753
86754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
86755   int jresult ;
86756   int result;
86757
86758   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
86759   jresult = (int)result;
86760   return jresult;
86761 }
86762
86763
86764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
86765   int jresult ;
86766   int result;
86767
86768   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
86769   jresult = (int)result;
86770   return jresult;
86771 }
86772
86773
86774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
86775   int jresult ;
86776   int result;
86777
86778   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
86779   jresult = (int)result;
86780   return jresult;
86781 }
86782
86783
86784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
86785   int jresult ;
86786   int result;
86787
86788   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
86789   jresult = (int)result;
86790   return jresult;
86791 }
86792
86793
86794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
86795   int jresult ;
86796   int result;
86797
86798   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
86799   jresult = (int)result;
86800   return jresult;
86801 }
86802
86803
86804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
86805   int jresult ;
86806   int result;
86807
86808   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
86809   jresult = (int)result;
86810   return jresult;
86811 }
86812
86813
86814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
86815   int jresult ;
86816   int result;
86817
86818   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
86819   jresult = (int)result;
86820   return jresult;
86821 }
86822
86823
86824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
86825   int jresult ;
86826   int result;
86827
86828   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
86829   jresult = (int)result;
86830   return jresult;
86831 }
86832
86833
86834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
86835   int jresult ;
86836   int result;
86837
86838   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
86839   jresult = (int)result;
86840   return jresult;
86841 }
86842
86843
86844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
86845   int jresult ;
86846   int result;
86847
86848   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
86849   jresult = (int)result;
86850   return jresult;
86851 }
86852
86853
86854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
86855   int jresult ;
86856   int result;
86857
86858   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
86859   jresult = (int)result;
86860   return jresult;
86861 }
86862
86863
86864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
86865   int jresult ;
86866   int result;
86867
86868   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
86869   jresult = (int)result;
86870   return jresult;
86871 }
86872
86873
86874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
86875   int jresult ;
86876   int result;
86877
86878   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
86879   jresult = (int)result;
86880   return jresult;
86881 }
86882
86883
86884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
86885   int jresult ;
86886   int result;
86887
86888   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
86889   jresult = (int)result;
86890   return jresult;
86891 }
86892
86893
86894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
86895   int jresult ;
86896   int result;
86897
86898   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
86899   jresult = (int)result;
86900   return jresult;
86901 }
86902
86903
86904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
86905   int jresult ;
86906   int result;
86907
86908   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
86909   jresult = (int)result;
86910   return jresult;
86911 }
86912
86913
86914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
86915   void * jresult ;
86916   Dali::Toolkit::Popup::Property *result = 0 ;
86917
86918   {
86919     try {
86920       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
86921     } catch (std::out_of_range& e) {
86922       {
86923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86924       };
86925     } catch (std::exception& e) {
86926       {
86927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86928       };
86929     } catch (Dali::DaliException e) {
86930       {
86931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86932       };
86933     } catch (...) {
86934       {
86935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86936       };
86937     }
86938   }
86939
86940   jresult = (void *)result;
86941   return jresult;
86942 }
86943
86944
86945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
86946   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
86947
86948   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
86949   {
86950     try {
86951       delete arg1;
86952     } catch (std::out_of_range& e) {
86953       {
86954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86955       };
86956     } catch (std::exception& e) {
86957       {
86958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86959       };
86960     } catch (Dali::DaliException e) {
86961       {
86962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86963       };
86964     } catch (...) {
86965       {
86966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86967       };
86968     }
86969   }
86970
86971 }
86972
86973
86974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
86975   void * jresult ;
86976   Dali::Toolkit::Popup *result = 0 ;
86977
86978   {
86979     try {
86980       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
86981     } catch (std::out_of_range& e) {
86982       {
86983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86984       };
86985     } catch (std::exception& e) {
86986       {
86987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86988       };
86989     } catch (Dali::DaliException e) {
86990       {
86991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86992       };
86993     } catch (...) {
86994       {
86995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86996       };
86997     }
86998   }
86999
87000   jresult = (void *)result;
87001   return jresult;
87002 }
87003
87004
87005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
87006   void * jresult ;
87007   Dali::Toolkit::Popup result;
87008
87009   {
87010     try {
87011       result = Dali::Toolkit::Popup::New();
87012     } catch (std::out_of_range& e) {
87013       {
87014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87015       };
87016     } catch (std::exception& e) {
87017       {
87018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87019       };
87020     } catch (Dali::DaliException e) {
87021       {
87022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87023       };
87024     } catch (...) {
87025       {
87026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87027       };
87028     }
87029   }
87030
87031   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
87032   return jresult;
87033 }
87034
87035
87036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
87037   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87038
87039   arg1 = (Dali::Toolkit::Popup *)jarg1;
87040   {
87041     try {
87042       delete arg1;
87043     } catch (std::out_of_range& e) {
87044       {
87045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87046       };
87047     } catch (std::exception& e) {
87048       {
87049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87050       };
87051     } catch (Dali::DaliException e) {
87052       {
87053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87054       };
87055     } catch (...) {
87056       {
87057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87058       };
87059     }
87060   }
87061
87062 }
87063
87064
87065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
87066   void * jresult ;
87067   Dali::Toolkit::Popup *arg1 = 0 ;
87068   Dali::Toolkit::Popup *result = 0 ;
87069
87070   arg1 = (Dali::Toolkit::Popup *)jarg1;
87071   if (!arg1) {
87072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
87073     return 0;
87074   }
87075   {
87076     try {
87077       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
87078     } catch (std::out_of_range& e) {
87079       {
87080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87081       };
87082     } catch (std::exception& e) {
87083       {
87084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87085       };
87086     } catch (Dali::DaliException e) {
87087       {
87088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87089       };
87090     } catch (...) {
87091       {
87092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87093       };
87094     }
87095   }
87096
87097   jresult = (void *)result;
87098   return jresult;
87099 }
87100
87101
87102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
87103   void * jresult ;
87104   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87105   Dali::Toolkit::Popup *arg2 = 0 ;
87106   Dali::Toolkit::Popup *result = 0 ;
87107
87108   arg1 = (Dali::Toolkit::Popup *)jarg1;
87109   arg2 = (Dali::Toolkit::Popup *)jarg2;
87110   if (!arg2) {
87111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
87112     return 0;
87113   }
87114   {
87115     try {
87116       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
87117     } catch (std::out_of_range& e) {
87118       {
87119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87120       };
87121     } catch (std::exception& e) {
87122       {
87123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87124       };
87125     } catch (Dali::DaliException e) {
87126       {
87127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87128       };
87129     } catch (...) {
87130       {
87131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87132       };
87133     }
87134   }
87135
87136   jresult = (void *)result;
87137   return jresult;
87138 }
87139
87140
87141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
87142   void * jresult ;
87143   Dali::BaseHandle arg1 ;
87144   Dali::BaseHandle *argp1 ;
87145   Dali::Toolkit::Popup result;
87146
87147   argp1 = (Dali::BaseHandle *)jarg1;
87148   if (!argp1) {
87149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87150     return 0;
87151   }
87152   arg1 = *argp1;
87153   {
87154     try {
87155       result = Dali::Toolkit::Popup::DownCast(arg1);
87156     } catch (std::out_of_range& e) {
87157       {
87158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87159       };
87160     } catch (std::exception& e) {
87161       {
87162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87163       };
87164     } catch (Dali::DaliException e) {
87165       {
87166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87167       };
87168     } catch (...) {
87169       {
87170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87171       };
87172     }
87173   }
87174
87175   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
87176   return jresult;
87177 }
87178
87179
87180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
87181   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87182   Dali::Actor arg2 ;
87183   Dali::Actor *argp2 ;
87184
87185   arg1 = (Dali::Toolkit::Popup *)jarg1;
87186   argp2 = (Dali::Actor *)jarg2;
87187   if (!argp2) {
87188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87189     return ;
87190   }
87191   arg2 = *argp2;
87192   {
87193     try {
87194       (arg1)->SetTitle(arg2);
87195     } catch (std::out_of_range& e) {
87196       {
87197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87198       };
87199     } catch (std::exception& e) {
87200       {
87201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87202       };
87203     } catch (Dali::DaliException e) {
87204       {
87205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87206       };
87207     } catch (...) {
87208       {
87209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87210       };
87211     }
87212   }
87213
87214 }
87215
87216
87217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
87218   void * jresult ;
87219   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87220   Dali::Actor result;
87221
87222   arg1 = (Dali::Toolkit::Popup *)jarg1;
87223   {
87224     try {
87225       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
87226     } catch (std::out_of_range& e) {
87227       {
87228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87229       };
87230     } catch (std::exception& e) {
87231       {
87232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87233       };
87234     } catch (Dali::DaliException e) {
87235       {
87236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87237       };
87238     } catch (...) {
87239       {
87240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87241       };
87242     }
87243   }
87244
87245   jresult = new Dali::Actor((const Dali::Actor &)result);
87246   return jresult;
87247 }
87248
87249
87250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
87251   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87252   Dali::Actor arg2 ;
87253   Dali::Actor *argp2 ;
87254
87255   arg1 = (Dali::Toolkit::Popup *)jarg1;
87256   argp2 = (Dali::Actor *)jarg2;
87257   if (!argp2) {
87258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87259     return ;
87260   }
87261   arg2 = *argp2;
87262   {
87263     try {
87264       (arg1)->SetContent(arg2);
87265     } catch (std::out_of_range& e) {
87266       {
87267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87268       };
87269     } catch (std::exception& e) {
87270       {
87271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87272       };
87273     } catch (Dali::DaliException e) {
87274       {
87275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87276       };
87277     } catch (...) {
87278       {
87279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87280       };
87281     }
87282   }
87283
87284 }
87285
87286
87287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
87288   void * jresult ;
87289   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87290   Dali::Actor result;
87291
87292   arg1 = (Dali::Toolkit::Popup *)jarg1;
87293   {
87294     try {
87295       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
87296     } catch (std::out_of_range& e) {
87297       {
87298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87299       };
87300     } catch (std::exception& e) {
87301       {
87302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87303       };
87304     } catch (Dali::DaliException e) {
87305       {
87306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87307       };
87308     } catch (...) {
87309       {
87310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87311       };
87312     }
87313   }
87314
87315   jresult = new Dali::Actor((const Dali::Actor &)result);
87316   return jresult;
87317 }
87318
87319
87320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
87321   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87322   Dali::Actor arg2 ;
87323   Dali::Actor *argp2 ;
87324
87325   arg1 = (Dali::Toolkit::Popup *)jarg1;
87326   argp2 = (Dali::Actor *)jarg2;
87327   if (!argp2) {
87328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87329     return ;
87330   }
87331   arg2 = *argp2;
87332   {
87333     try {
87334       (arg1)->SetFooter(arg2);
87335     } catch (std::out_of_range& e) {
87336       {
87337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87338       };
87339     } catch (std::exception& e) {
87340       {
87341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87342       };
87343     } catch (Dali::DaliException e) {
87344       {
87345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87346       };
87347     } catch (...) {
87348       {
87349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87350       };
87351     }
87352   }
87353
87354 }
87355
87356
87357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
87358   void * jresult ;
87359   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87360   Dali::Actor result;
87361
87362   arg1 = (Dali::Toolkit::Popup *)jarg1;
87363   {
87364     try {
87365       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
87366     } catch (std::out_of_range& e) {
87367       {
87368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87369       };
87370     } catch (std::exception& e) {
87371       {
87372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87373       };
87374     } catch (Dali::DaliException e) {
87375       {
87376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87377       };
87378     } catch (...) {
87379       {
87380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87381       };
87382     }
87383   }
87384
87385   jresult = new Dali::Actor((const Dali::Actor &)result);
87386   return jresult;
87387 }
87388
87389
87390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
87391   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87392   Dali::Toolkit::Popup::DisplayState arg2 ;
87393
87394   arg1 = (Dali::Toolkit::Popup *)jarg1;
87395   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
87396   {
87397     try {
87398       (arg1)->SetDisplayState(arg2);
87399     } catch (std::out_of_range& e) {
87400       {
87401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87402       };
87403     } catch (std::exception& e) {
87404       {
87405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87406       };
87407     } catch (Dali::DaliException e) {
87408       {
87409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87410       };
87411     } catch (...) {
87412       {
87413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87414       };
87415     }
87416   }
87417
87418 }
87419
87420
87421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
87422   int jresult ;
87423   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87424   Dali::Toolkit::Popup::DisplayState result;
87425
87426   arg1 = (Dali::Toolkit::Popup *)jarg1;
87427   {
87428     try {
87429       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
87430     } catch (std::out_of_range& e) {
87431       {
87432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87433       };
87434     } catch (std::exception& e) {
87435       {
87436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87437       };
87438     } catch (Dali::DaliException e) {
87439       {
87440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87441       };
87442     } catch (...) {
87443       {
87444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87445       };
87446     }
87447   }
87448
87449   jresult = (int)result;
87450   return jresult;
87451 }
87452
87453
87454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
87455   void * jresult ;
87456   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87457   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
87458
87459   arg1 = (Dali::Toolkit::Popup *)jarg1;
87460   {
87461     try {
87462       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
87463     } catch (std::out_of_range& e) {
87464       {
87465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87466       };
87467     } catch (std::exception& e) {
87468       {
87469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87470       };
87471     } catch (Dali::DaliException e) {
87472       {
87473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87474       };
87475     } catch (...) {
87476       {
87477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87478       };
87479     }
87480   }
87481
87482   jresult = (void *)result;
87483   return jresult;
87484 }
87485
87486
87487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
87488   void * jresult ;
87489   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87490   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87491
87492   arg1 = (Dali::Toolkit::Popup *)jarg1;
87493   {
87494     try {
87495       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
87496     } catch (std::out_of_range& e) {
87497       {
87498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87499       };
87500     } catch (std::exception& e) {
87501       {
87502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87503       };
87504     } catch (Dali::DaliException e) {
87505       {
87506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87507       };
87508     } catch (...) {
87509       {
87510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87511       };
87512     }
87513   }
87514
87515   jresult = (void *)result;
87516   return jresult;
87517 }
87518
87519
87520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
87521   void * jresult ;
87522   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87523   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87524
87525   arg1 = (Dali::Toolkit::Popup *)jarg1;
87526   {
87527     try {
87528       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
87529     } catch (std::out_of_range& e) {
87530       {
87531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87532       };
87533     } catch (std::exception& e) {
87534       {
87535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87536       };
87537     } catch (Dali::DaliException e) {
87538       {
87539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87540       };
87541     } catch (...) {
87542       {
87543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87544       };
87545     }
87546   }
87547
87548   jresult = (void *)result;
87549   return jresult;
87550 }
87551
87552
87553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
87554   void * jresult ;
87555   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87556   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87557
87558   arg1 = (Dali::Toolkit::Popup *)jarg1;
87559   {
87560     try {
87561       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
87562     } catch (std::out_of_range& e) {
87563       {
87564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87565       };
87566     } catch (std::exception& e) {
87567       {
87568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87569       };
87570     } catch (Dali::DaliException e) {
87571       {
87572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87573       };
87574     } catch (...) {
87575       {
87576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87577       };
87578     }
87579   }
87580
87581   jresult = (void *)result;
87582   return jresult;
87583 }
87584
87585
87586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
87587   void * jresult ;
87588   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87589   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87590
87591   arg1 = (Dali::Toolkit::Popup *)jarg1;
87592   {
87593     try {
87594       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
87595     } catch (std::out_of_range& e) {
87596       {
87597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87598       };
87599     } catch (std::exception& e) {
87600       {
87601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87602       };
87603     } catch (Dali::DaliException e) {
87604       {
87605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87606       };
87607     } catch (...) {
87608       {
87609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87610       };
87611     }
87612   }
87613
87614   jresult = (void *)result;
87615   return jresult;
87616 }
87617
87618
87619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
87620   int jresult ;
87621   int result;
87622
87623   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
87624   jresult = (int)result;
87625   return jresult;
87626 }
87627
87628
87629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
87630   int jresult ;
87631   int result;
87632
87633   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
87634   jresult = (int)result;
87635   return jresult;
87636 }
87637
87638
87639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
87640   int jresult ;
87641   int result;
87642
87643   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
87644   jresult = (int)result;
87645   return jresult;
87646 }
87647
87648
87649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
87650   int jresult ;
87651   int result;
87652
87653   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
87654   jresult = (int)result;
87655   return jresult;
87656 }
87657
87658
87659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
87660   int jresult ;
87661   int result;
87662
87663   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
87664   jresult = (int)result;
87665   return jresult;
87666 }
87667
87668
87669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
87670   int jresult ;
87671   int result;
87672
87673   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
87674   jresult = (int)result;
87675   return jresult;
87676 }
87677
87678
87679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
87680   int jresult ;
87681   int result;
87682
87683   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
87684   jresult = (int)result;
87685   return jresult;
87686 }
87687
87688
87689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
87690   int jresult ;
87691   int result;
87692
87693   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
87694   jresult = (int)result;
87695   return jresult;
87696 }
87697
87698
87699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
87700   int jresult ;
87701   int result;
87702
87703   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
87704   jresult = (int)result;
87705   return jresult;
87706 }
87707
87708
87709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
87710   void * jresult ;
87711   Dali::Toolkit::ProgressBar::Property *result = 0 ;
87712
87713   {
87714     try {
87715       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
87716     } catch (std::out_of_range& e) {
87717       {
87718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87719       };
87720     } catch (std::exception& e) {
87721       {
87722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87723       };
87724     } catch (Dali::DaliException e) {
87725       {
87726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87727       };
87728     } catch (...) {
87729       {
87730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87731       };
87732     }
87733   }
87734
87735   jresult = (void *)result;
87736   return jresult;
87737 }
87738
87739
87740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
87741   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
87742
87743   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
87744   {
87745     try {
87746       delete arg1;
87747     } catch (std::out_of_range& e) {
87748       {
87749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87750       };
87751     } catch (std::exception& e) {
87752       {
87753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87754       };
87755     } catch (Dali::DaliException e) {
87756       {
87757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87758       };
87759     } catch (...) {
87760       {
87761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87762       };
87763     }
87764   }
87765
87766 }
87767
87768
87769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
87770   void * jresult ;
87771   Dali::Toolkit::ProgressBar result;
87772
87773   {
87774     try {
87775       result = Dali::Toolkit::ProgressBar::New();
87776     } catch (std::out_of_range& e) {
87777       {
87778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87779       };
87780     } catch (std::exception& e) {
87781       {
87782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87783       };
87784     } catch (Dali::DaliException e) {
87785       {
87786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87787       };
87788     } catch (...) {
87789       {
87790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87791       };
87792     }
87793   }
87794
87795   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
87796   return jresult;
87797 }
87798
87799
87800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
87801   void * jresult ;
87802   Dali::Toolkit::ProgressBar *result = 0 ;
87803
87804   {
87805     try {
87806       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
87807     } catch (std::out_of_range& e) {
87808       {
87809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87810       };
87811     } catch (std::exception& e) {
87812       {
87813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87814       };
87815     } catch (Dali::DaliException e) {
87816       {
87817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87818       };
87819     } catch (...) {
87820       {
87821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87822       };
87823     }
87824   }
87825
87826   jresult = (void *)result;
87827   return jresult;
87828 }
87829
87830
87831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
87832   void * jresult ;
87833   Dali::Toolkit::ProgressBar *arg1 = 0 ;
87834   Dali::Toolkit::ProgressBar *result = 0 ;
87835
87836   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87837   if (!arg1) {
87838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
87839     return 0;
87840   }
87841   {
87842     try {
87843       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
87844     } catch (std::out_of_range& e) {
87845       {
87846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87847       };
87848     } catch (std::exception& e) {
87849       {
87850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87851       };
87852     } catch (Dali::DaliException e) {
87853       {
87854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87855       };
87856     } catch (...) {
87857       {
87858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87859       };
87860     }
87861   }
87862
87863   jresult = (void *)result;
87864   return jresult;
87865 }
87866
87867
87868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
87869   void * jresult ;
87870   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87871   Dali::Toolkit::ProgressBar *arg2 = 0 ;
87872   Dali::Toolkit::ProgressBar *result = 0 ;
87873
87874   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87875   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
87876   if (!arg2) {
87877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
87878     return 0;
87879   }
87880   {
87881     try {
87882       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
87883     } catch (std::out_of_range& e) {
87884       {
87885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87886       };
87887     } catch (std::exception& e) {
87888       {
87889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87890       };
87891     } catch (Dali::DaliException e) {
87892       {
87893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87894       };
87895     } catch (...) {
87896       {
87897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87898       };
87899     }
87900   }
87901
87902   jresult = (void *)result;
87903   return jresult;
87904 }
87905
87906
87907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
87908   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87909
87910   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87911   {
87912     try {
87913       delete arg1;
87914     } catch (std::out_of_range& e) {
87915       {
87916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87917       };
87918     } catch (std::exception& e) {
87919       {
87920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87921       };
87922     } catch (Dali::DaliException e) {
87923       {
87924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87925       };
87926     } catch (...) {
87927       {
87928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87929       };
87930     }
87931   }
87932
87933 }
87934
87935
87936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
87937   void * jresult ;
87938   Dali::BaseHandle arg1 ;
87939   Dali::BaseHandle *argp1 ;
87940   Dali::Toolkit::ProgressBar result;
87941
87942   argp1 = (Dali::BaseHandle *)jarg1;
87943   if (!argp1) {
87944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87945     return 0;
87946   }
87947   arg1 = *argp1;
87948   {
87949     try {
87950       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
87951     } catch (std::out_of_range& e) {
87952       {
87953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87954       };
87955     } catch (std::exception& e) {
87956       {
87957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87958       };
87959     } catch (Dali::DaliException e) {
87960       {
87961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87962       };
87963     } catch (...) {
87964       {
87965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87966       };
87967     }
87968   }
87969
87970   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
87971   return jresult;
87972 }
87973
87974
87975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
87976   void * jresult ;
87977   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87978   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
87979
87980   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87981   {
87982     try {
87983       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87984     } catch (std::out_of_range& e) {
87985       {
87986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87987       };
87988     } catch (std::exception& e) {
87989       {
87990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87991       };
87992     } catch (Dali::DaliException e) {
87993       {
87994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87995       };
87996     } catch (...) {
87997       {
87998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87999       };
88000     }
88001   }
88002
88003   jresult = (void *)result;
88004   return jresult;
88005 }
88006
88007
88008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
88009   void * jresult ;
88010   Dali::Toolkit::GaussianBlurView *result = 0 ;
88011
88012   {
88013     try {
88014       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
88015     } catch (std::out_of_range& e) {
88016       {
88017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88018       };
88019     } catch (std::exception& e) {
88020       {
88021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88022       };
88023     } catch (Dali::DaliException e) {
88024       {
88025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88026       };
88027     } catch (...) {
88028       {
88029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88030       };
88031     }
88032   }
88033
88034   jresult = (void *)result;
88035   return jresult;
88036 }
88037
88038
88039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
88040   void * jresult ;
88041   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
88042   Dali::Toolkit::GaussianBlurView *result = 0 ;
88043
88044   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88045   if (!arg1) {
88046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
88047     return 0;
88048   }
88049   {
88050     try {
88051       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
88052     } catch (std::out_of_range& e) {
88053       {
88054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88055       };
88056     } catch (std::exception& e) {
88057       {
88058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88059       };
88060     } catch (Dali::DaliException e) {
88061       {
88062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88063       };
88064     } catch (...) {
88065       {
88066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88067       };
88068     }
88069   }
88070
88071   jresult = (void *)result;
88072   return jresult;
88073 }
88074
88075
88076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
88077   void * jresult ;
88078   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88079   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
88080   Dali::Toolkit::GaussianBlurView *result = 0 ;
88081
88082   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88083   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
88084   if (!arg2) {
88085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
88086     return 0;
88087   }
88088   {
88089     try {
88090       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
88091     } catch (std::out_of_range& e) {
88092       {
88093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88094       };
88095     } catch (std::exception& e) {
88096       {
88097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88098       };
88099     } catch (Dali::DaliException e) {
88100       {
88101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88102       };
88103     } catch (...) {
88104       {
88105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88106       };
88107     }
88108   }
88109
88110   jresult = (void *)result;
88111   return jresult;
88112 }
88113
88114
88115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
88116   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88117
88118   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88119   {
88120     try {
88121       delete arg1;
88122     } catch (std::out_of_range& e) {
88123       {
88124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88125       };
88126     } catch (std::exception& e) {
88127       {
88128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88129       };
88130     } catch (Dali::DaliException e) {
88131       {
88132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88133       };
88134     } catch (...) {
88135       {
88136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88137       };
88138     }
88139   }
88140
88141 }
88142
88143
88144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
88145   void * jresult ;
88146   Dali::BaseHandle arg1 ;
88147   Dali::BaseHandle *argp1 ;
88148   Dali::Toolkit::GaussianBlurView result;
88149
88150   argp1 = (Dali::BaseHandle *)jarg1;
88151   if (!argp1) {
88152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88153     return 0;
88154   }
88155   arg1 = *argp1;
88156   {
88157     try {
88158       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
88159     } catch (std::out_of_range& e) {
88160       {
88161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88162       };
88163     } catch (std::exception& e) {
88164       {
88165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88166       };
88167     } catch (Dali::DaliException e) {
88168       {
88169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88170       };
88171     } catch (...) {
88172       {
88173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88174       };
88175     }
88176   }
88177
88178   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88179   return jresult;
88180 }
88181
88182
88183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
88184   void * jresult ;
88185   Dali::Toolkit::GaussianBlurView result;
88186
88187   {
88188     try {
88189       result = Dali::Toolkit::GaussianBlurView::New();
88190     } catch (std::out_of_range& e) {
88191       {
88192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88193       };
88194     } catch (std::exception& e) {
88195       {
88196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88197       };
88198     } catch (Dali::DaliException e) {
88199       {
88200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88201       };
88202     } catch (...) {
88203       {
88204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88205       };
88206     }
88207   }
88208
88209   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88210   return jresult;
88211 }
88212
88213
88214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
88215   void * jresult ;
88216   unsigned int arg1 ;
88217   float arg2 ;
88218   Dali::Pixel::Format arg3 ;
88219   float arg4 ;
88220   float arg5 ;
88221   bool arg6 ;
88222   Dali::Toolkit::GaussianBlurView result;
88223
88224   arg1 = (unsigned int)jarg1;
88225   arg2 = (float)jarg2;
88226   arg3 = (Dali::Pixel::Format)jarg3;
88227   arg4 = (float)jarg4;
88228   arg5 = (float)jarg5;
88229   arg6 = jarg6 ? true : false;
88230   {
88231     try {
88232       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
88233     } catch (std::out_of_range& e) {
88234       {
88235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88236       };
88237     } catch (std::exception& e) {
88238       {
88239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88240       };
88241     } catch (Dali::DaliException e) {
88242       {
88243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88244       };
88245     } catch (...) {
88246       {
88247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88248       };
88249     }
88250   }
88251
88252   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88253   return jresult;
88254 }
88255
88256
88257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
88258   void * jresult ;
88259   unsigned int arg1 ;
88260   float arg2 ;
88261   Dali::Pixel::Format arg3 ;
88262   float arg4 ;
88263   float arg5 ;
88264   Dali::Toolkit::GaussianBlurView result;
88265
88266   arg1 = (unsigned int)jarg1;
88267   arg2 = (float)jarg2;
88268   arg3 = (Dali::Pixel::Format)jarg3;
88269   arg4 = (float)jarg4;
88270   arg5 = (float)jarg5;
88271   {
88272     try {
88273       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
88274     } catch (std::out_of_range& e) {
88275       {
88276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88277       };
88278     } catch (std::exception& e) {
88279       {
88280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88281       };
88282     } catch (Dali::DaliException e) {
88283       {
88284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88285       };
88286     } catch (...) {
88287       {
88288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88289       };
88290     }
88291   }
88292
88293   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88294   return jresult;
88295 }
88296
88297
88298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
88299   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88300   Dali::Actor arg2 ;
88301   Dali::Actor *argp2 ;
88302
88303   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88304   argp2 = (Dali::Actor *)jarg2;
88305   if (!argp2) {
88306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88307     return ;
88308   }
88309   arg2 = *argp2;
88310   {
88311     try {
88312       (arg1)->Add(arg2);
88313     } catch (std::out_of_range& e) {
88314       {
88315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88316       };
88317     } catch (std::exception& e) {
88318       {
88319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88320       };
88321     } catch (Dali::DaliException e) {
88322       {
88323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88324       };
88325     } catch (...) {
88326       {
88327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88328       };
88329     }
88330   }
88331
88332 }
88333
88334
88335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
88336   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88337   Dali::Actor arg2 ;
88338   Dali::Actor *argp2 ;
88339
88340   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88341   argp2 = (Dali::Actor *)jarg2;
88342   if (!argp2) {
88343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88344     return ;
88345   }
88346   arg2 = *argp2;
88347   {
88348     try {
88349       (arg1)->Remove(arg2);
88350     } catch (std::out_of_range& e) {
88351       {
88352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88353       };
88354     } catch (std::exception& e) {
88355       {
88356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88357       };
88358     } catch (Dali::DaliException e) {
88359       {
88360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88361       };
88362     } catch (...) {
88363       {
88364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88365       };
88366     }
88367   }
88368
88369 }
88370
88371
88372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
88373   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88374
88375   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88376   {
88377     try {
88378       (arg1)->Activate();
88379     } catch (std::out_of_range& e) {
88380       {
88381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88382       };
88383     } catch (std::exception& e) {
88384       {
88385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88386       };
88387     } catch (Dali::DaliException e) {
88388       {
88389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88390       };
88391     } catch (...) {
88392       {
88393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88394       };
88395     }
88396   }
88397
88398 }
88399
88400
88401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
88402   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88403
88404   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88405   {
88406     try {
88407       (arg1)->ActivateOnce();
88408     } catch (std::out_of_range& e) {
88409       {
88410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88411       };
88412     } catch (std::exception& e) {
88413       {
88414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88415       };
88416     } catch (Dali::DaliException e) {
88417       {
88418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88419       };
88420     } catch (...) {
88421       {
88422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88423       };
88424     }
88425   }
88426
88427 }
88428
88429
88430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
88431   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88432
88433   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88434   {
88435     try {
88436       (arg1)->Deactivate();
88437     } catch (std::out_of_range& e) {
88438       {
88439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88440       };
88441     } catch (std::exception& e) {
88442       {
88443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88444       };
88445     } catch (Dali::DaliException e) {
88446       {
88447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88448       };
88449     } catch (...) {
88450       {
88451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88452       };
88453     }
88454   }
88455
88456 }
88457
88458
88459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
88460   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88461   Dali::Texture arg2 ;
88462   Dali::FrameBuffer arg3 ;
88463   Dali::Texture *argp2 ;
88464   Dali::FrameBuffer *argp3 ;
88465
88466   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88467   argp2 = (Dali::Texture *)jarg2;
88468   if (!argp2) {
88469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
88470     return ;
88471   }
88472   arg2 = *argp2;
88473   argp3 = (Dali::FrameBuffer *)jarg3;
88474   if (!argp3) {
88475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
88476     return ;
88477   }
88478   arg3 = *argp3;
88479   {
88480     try {
88481       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
88482     } catch (std::out_of_range& e) {
88483       {
88484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88485       };
88486     } catch (std::exception& e) {
88487       {
88488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88489       };
88490     } catch (Dali::DaliException e) {
88491       {
88492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88493       };
88494     } catch (...) {
88495       {
88496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88497       };
88498     }
88499   }
88500
88501 }
88502
88503
88504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
88505   int jresult ;
88506   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88507   Dali::Property::Index result;
88508
88509   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88510   {
88511     try {
88512       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
88513     } catch (std::out_of_range& e) {
88514       {
88515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88516       };
88517     } catch (std::exception& e) {
88518       {
88519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88520       };
88521     } catch (Dali::DaliException e) {
88522       {
88523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88524       };
88525     } catch (...) {
88526       {
88527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88528       };
88529     }
88530   }
88531
88532   jresult = result;
88533   return jresult;
88534 }
88535
88536
88537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
88538   void * jresult ;
88539   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88540   Dali::FrameBuffer result;
88541
88542   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88543   {
88544     try {
88545       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
88546     } catch (std::out_of_range& e) {
88547       {
88548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88549       };
88550     } catch (std::exception& e) {
88551       {
88552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88553       };
88554     } catch (Dali::DaliException e) {
88555       {
88556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88557       };
88558     } catch (...) {
88559       {
88560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88561       };
88562     }
88563   }
88564
88565   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
88566   return jresult;
88567 }
88568
88569
88570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
88571   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88572   Dali::Vector4 *arg2 = 0 ;
88573
88574   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88575   arg2 = (Dali::Vector4 *)jarg2;
88576   if (!arg2) {
88577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
88578     return ;
88579   }
88580   {
88581     try {
88582       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
88583     } catch (std::out_of_range& e) {
88584       {
88585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88586       };
88587     } catch (std::exception& e) {
88588       {
88589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88590       };
88591     } catch (Dali::DaliException e) {
88592       {
88593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88594       };
88595     } catch (...) {
88596       {
88597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88598       };
88599     }
88600   }
88601
88602 }
88603
88604
88605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
88606   void * jresult ;
88607   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88608   Dali::Vector4 result;
88609
88610   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88611   {
88612     try {
88613       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
88614     } catch (std::out_of_range& e) {
88615       {
88616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88617       };
88618     } catch (std::exception& e) {
88619       {
88620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88621       };
88622     } catch (Dali::DaliException e) {
88623       {
88624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88625       };
88626     } catch (...) {
88627       {
88628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88629       };
88630     }
88631   }
88632
88633   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
88634   return jresult;
88635 }
88636
88637
88638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
88639   void * jresult ;
88640   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88641   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
88642
88643   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88644   {
88645     try {
88646       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
88647     } catch (std::out_of_range& e) {
88648       {
88649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88650       };
88651     } catch (std::exception& e) {
88652       {
88653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88654       };
88655     } catch (Dali::DaliException e) {
88656       {
88657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88658       };
88659     } catch (...) {
88660       {
88661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88662       };
88663     }
88664   }
88665
88666   jresult = (void *)result;
88667   return jresult;
88668 }
88669
88670
88671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
88672   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88673
88674   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88675   {
88676     try {
88677       delete arg1;
88678     } catch (std::out_of_range& e) {
88679       {
88680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88681       };
88682     } catch (std::exception& e) {
88683       {
88684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88685       };
88686     } catch (Dali::DaliException e) {
88687       {
88688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88689       };
88690     } catch (...) {
88691       {
88692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88693       };
88694     }
88695   }
88696
88697 }
88698
88699
88700 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
88701   unsigned int jresult ;
88702   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88703   unsigned int result;
88704
88705   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88706   {
88707     try {
88708       result = (unsigned int)(arg1)->GetNumberOfPages();
88709     } catch (std::out_of_range& e) {
88710       {
88711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88712       };
88713     } catch (std::exception& e) {
88714       {
88715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88716       };
88717     } catch (Dali::DaliException e) {
88718       {
88719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88720       };
88721     } catch (...) {
88722       {
88723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88724       };
88725     }
88726   }
88727
88728   jresult = result;
88729   return jresult;
88730 }
88731
88732
88733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
88734   void * jresult ;
88735   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88736   unsigned int arg2 ;
88737   Dali::Texture result;
88738
88739   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88740   arg2 = (unsigned int)jarg2;
88741   {
88742     try {
88743       result = (arg1)->NewPage(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 = new Dali::Texture((const Dali::Texture &)result);
88764   return jresult;
88765 }
88766
88767
88768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
88769   int jresult ;
88770   int result;
88771
88772   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
88773   jresult = (int)result;
88774   return jresult;
88775 }
88776
88777
88778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
88779   int jresult ;
88780   int result;
88781
88782   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
88783   jresult = (int)result;
88784   return jresult;
88785 }
88786
88787
88788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
88789   int jresult ;
88790   int result;
88791
88792   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
88793   jresult = (int)result;
88794   return jresult;
88795 }
88796
88797
88798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
88799   void * jresult ;
88800   Dali::Toolkit::PageTurnView::Property *result = 0 ;
88801
88802   {
88803     try {
88804       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
88805     } catch (std::out_of_range& e) {
88806       {
88807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88808       };
88809     } catch (std::exception& e) {
88810       {
88811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88812       };
88813     } catch (Dali::DaliException e) {
88814       {
88815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88816       };
88817     } catch (...) {
88818       {
88819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88820       };
88821     }
88822   }
88823
88824   jresult = (void *)result;
88825   return jresult;
88826 }
88827
88828
88829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
88830   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
88831
88832   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
88833   {
88834     try {
88835       delete arg1;
88836     } catch (std::out_of_range& e) {
88837       {
88838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88839       };
88840     } catch (std::exception& e) {
88841       {
88842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88843       };
88844     } catch (Dali::DaliException e) {
88845       {
88846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88847       };
88848     } catch (...) {
88849       {
88850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88851       };
88852     }
88853   }
88854
88855 }
88856
88857
88858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
88859   void * jresult ;
88860   Dali::Toolkit::PageTurnView *result = 0 ;
88861
88862   {
88863     try {
88864       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
88865     } catch (std::out_of_range& e) {
88866       {
88867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88868       };
88869     } catch (std::exception& e) {
88870       {
88871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88872       };
88873     } catch (Dali::DaliException e) {
88874       {
88875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88876       };
88877     } catch (...) {
88878       {
88879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88880       };
88881     }
88882   }
88883
88884   jresult = (void *)result;
88885   return jresult;
88886 }
88887
88888
88889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
88890   void * jresult ;
88891   Dali::Toolkit::PageTurnView *arg1 = 0 ;
88892   Dali::Toolkit::PageTurnView *result = 0 ;
88893
88894   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88895   if (!arg1) {
88896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
88897     return 0;
88898   }
88899   {
88900     try {
88901       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
88902     } catch (std::out_of_range& e) {
88903       {
88904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88905       };
88906     } catch (std::exception& e) {
88907       {
88908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88909       };
88910     } catch (Dali::DaliException e) {
88911       {
88912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88913       };
88914     } catch (...) {
88915       {
88916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88917       };
88918     }
88919   }
88920
88921   jresult = (void *)result;
88922   return jresult;
88923 }
88924
88925
88926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
88927   void * jresult ;
88928   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88929   Dali::Toolkit::PageTurnView *arg2 = 0 ;
88930   Dali::Toolkit::PageTurnView *result = 0 ;
88931
88932   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88933   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
88934   if (!arg2) {
88935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
88936     return 0;
88937   }
88938   {
88939     try {
88940       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
88941     } catch (std::out_of_range& e) {
88942       {
88943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88944       };
88945     } catch (std::exception& e) {
88946       {
88947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88948       };
88949     } catch (Dali::DaliException e) {
88950       {
88951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88952       };
88953     } catch (...) {
88954       {
88955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88956       };
88957     }
88958   }
88959
88960   jresult = (void *)result;
88961   return jresult;
88962 }
88963
88964
88965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
88966   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88967
88968   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88969   {
88970     try {
88971       delete arg1;
88972     } catch (std::out_of_range& e) {
88973       {
88974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88975       };
88976     } catch (std::exception& e) {
88977       {
88978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88979       };
88980     } catch (Dali::DaliException e) {
88981       {
88982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88983       };
88984     } catch (...) {
88985       {
88986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88987       };
88988     }
88989   }
88990
88991 }
88992
88993
88994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
88995   void * jresult ;
88996   Dali::BaseHandle arg1 ;
88997   Dali::BaseHandle *argp1 ;
88998   Dali::Toolkit::PageTurnView result;
88999
89000   argp1 = (Dali::BaseHandle *)jarg1;
89001   if (!argp1) {
89002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89003     return 0;
89004   }
89005   arg1 = *argp1;
89006   {
89007     try {
89008       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
89009     } catch (std::out_of_range& e) {
89010       {
89011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89012       };
89013     } catch (std::exception& e) {
89014       {
89015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89016       };
89017     } catch (Dali::DaliException e) {
89018       {
89019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89020       };
89021     } catch (...) {
89022       {
89023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89024       };
89025     }
89026   }
89027
89028   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
89029   return jresult;
89030 }
89031
89032
89033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
89034   void * jresult ;
89035   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89036   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
89037
89038   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89039   {
89040     try {
89041       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
89042     } catch (std::out_of_range& e) {
89043       {
89044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89045       };
89046     } catch (std::exception& e) {
89047       {
89048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89049       };
89050     } catch (Dali::DaliException e) {
89051       {
89052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89053       };
89054     } catch (...) {
89055       {
89056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89057       };
89058     }
89059   }
89060
89061   jresult = (void *)result;
89062   return jresult;
89063 }
89064
89065
89066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
89067   void * jresult ;
89068   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89069   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
89070
89071   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89072   {
89073     try {
89074       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
89075     } catch (std::out_of_range& e) {
89076       {
89077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89078       };
89079     } catch (std::exception& e) {
89080       {
89081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89082       };
89083     } catch (Dali::DaliException e) {
89084       {
89085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89086       };
89087     } catch (...) {
89088       {
89089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89090       };
89091     }
89092   }
89093
89094   jresult = (void *)result;
89095   return jresult;
89096 }
89097
89098
89099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
89100   void * jresult ;
89101   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89102   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
89103
89104   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89105   {
89106     try {
89107       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
89108     } catch (std::out_of_range& e) {
89109       {
89110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89111       };
89112     } catch (std::exception& e) {
89113       {
89114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89115       };
89116     } catch (Dali::DaliException e) {
89117       {
89118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89119       };
89120     } catch (...) {
89121       {
89122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89123       };
89124     }
89125   }
89126
89127   jresult = (void *)result;
89128   return jresult;
89129 }
89130
89131
89132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
89133   void * jresult ;
89134   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89135   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
89136
89137   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89138   {
89139     try {
89140       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
89141     } catch (std::out_of_range& e) {
89142       {
89143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89144       };
89145     } catch (std::exception& e) {
89146       {
89147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89148       };
89149     } catch (Dali::DaliException e) {
89150       {
89151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89152       };
89153     } catch (...) {
89154       {
89155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89156       };
89157     }
89158   }
89159
89160   jresult = (void *)result;
89161   return jresult;
89162 }
89163
89164
89165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
89166   void * jresult ;
89167   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89168
89169   {
89170     try {
89171       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
89172     } catch (std::out_of_range& e) {
89173       {
89174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89175       };
89176     } catch (std::exception& e) {
89177       {
89178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89179       };
89180     } catch (Dali::DaliException e) {
89181       {
89182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89183       };
89184     } catch (...) {
89185       {
89186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89187       };
89188     }
89189   }
89190
89191   jresult = (void *)result;
89192   return jresult;
89193 }
89194
89195
89196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
89197   void * jresult ;
89198   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
89199   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89200
89201   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89202   if (!arg1) {
89203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89204     return 0;
89205   }
89206   {
89207     try {
89208       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
89209     } catch (std::out_of_range& e) {
89210       {
89211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89212       };
89213     } catch (std::exception& e) {
89214       {
89215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89216       };
89217     } catch (Dali::DaliException e) {
89218       {
89219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89220       };
89221     } catch (...) {
89222       {
89223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89224       };
89225     }
89226   }
89227
89228   jresult = (void *)result;
89229   return jresult;
89230 }
89231
89232
89233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
89234   void * jresult ;
89235   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
89236   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
89237   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89238
89239   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89240   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
89241   if (!arg2) {
89242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89243     return 0;
89244   }
89245   {
89246     try {
89247       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
89248     } catch (std::out_of_range& e) {
89249       {
89250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89251       };
89252     } catch (std::exception& e) {
89253       {
89254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89255       };
89256     } catch (Dali::DaliException e) {
89257       {
89258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89259       };
89260     } catch (...) {
89261       {
89262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89263       };
89264     }
89265   }
89266
89267   jresult = (void *)result;
89268   return jresult;
89269 }
89270
89271
89272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
89273   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
89274
89275   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89276   {
89277     try {
89278       delete arg1;
89279     } catch (std::out_of_range& e) {
89280       {
89281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89282       };
89283     } catch (std::exception& e) {
89284       {
89285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89286       };
89287     } catch (Dali::DaliException e) {
89288       {
89289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89290       };
89291     } catch (...) {
89292       {
89293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89294       };
89295     }
89296   }
89297
89298 }
89299
89300
89301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
89302   void * jresult ;
89303   Dali::Toolkit::PageFactory *arg1 = 0 ;
89304   Dali::Vector2 *arg2 = 0 ;
89305   Dali::Toolkit::PageTurnLandscapeView result;
89306
89307   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89308   if (!arg1) {
89309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
89310     return 0;
89311   }
89312   arg2 = (Dali::Vector2 *)jarg2;
89313   if (!arg2) {
89314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
89315     return 0;
89316   }
89317   {
89318     try {
89319       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
89320     } catch (std::out_of_range& e) {
89321       {
89322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89323       };
89324     } catch (std::exception& e) {
89325       {
89326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89327       };
89328     } catch (Dali::DaliException e) {
89329       {
89330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89331       };
89332     } catch (...) {
89333       {
89334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89335       };
89336     }
89337   }
89338
89339   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
89340   return jresult;
89341 }
89342
89343
89344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
89345   void * jresult ;
89346   Dali::BaseHandle arg1 ;
89347   Dali::BaseHandle *argp1 ;
89348   Dali::Toolkit::PageTurnLandscapeView result;
89349
89350   argp1 = (Dali::BaseHandle *)jarg1;
89351   if (!argp1) {
89352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89353     return 0;
89354   }
89355   arg1 = *argp1;
89356   {
89357     try {
89358       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
89359     } catch (std::out_of_range& e) {
89360       {
89361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89362       };
89363     } catch (std::exception& e) {
89364       {
89365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89366       };
89367     } catch (Dali::DaliException e) {
89368       {
89369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89370       };
89371     } catch (...) {
89372       {
89373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89374       };
89375     }
89376   }
89377
89378   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
89379   return jresult;
89380 }
89381
89382
89383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
89384   void * jresult ;
89385   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89386
89387   {
89388     try {
89389       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
89390     } catch (std::out_of_range& e) {
89391       {
89392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89393       };
89394     } catch (std::exception& e) {
89395       {
89396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89397       };
89398     } catch (Dali::DaliException e) {
89399       {
89400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89401       };
89402     } catch (...) {
89403       {
89404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89405       };
89406     }
89407   }
89408
89409   jresult = (void *)result;
89410   return jresult;
89411 }
89412
89413
89414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
89415   void * jresult ;
89416   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
89417   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89418
89419   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89420   if (!arg1) {
89421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
89422     return 0;
89423   }
89424   {
89425     try {
89426       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
89427     } catch (std::out_of_range& e) {
89428       {
89429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89430       };
89431     } catch (std::exception& e) {
89432       {
89433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89434       };
89435     } catch (Dali::DaliException e) {
89436       {
89437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89438       };
89439     } catch (...) {
89440       {
89441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89442       };
89443     }
89444   }
89445
89446   jresult = (void *)result;
89447   return jresult;
89448 }
89449
89450
89451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
89452   void * jresult ;
89453   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
89454   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
89455   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89456
89457   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89458   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
89459   if (!arg2) {
89460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
89461     return 0;
89462   }
89463   {
89464     try {
89465       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
89466     } catch (std::out_of_range& e) {
89467       {
89468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89469       };
89470     } catch (std::exception& e) {
89471       {
89472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89473       };
89474     } catch (Dali::DaliException e) {
89475       {
89476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89477       };
89478     } catch (...) {
89479       {
89480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89481       };
89482     }
89483   }
89484
89485   jresult = (void *)result;
89486   return jresult;
89487 }
89488
89489
89490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
89491   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
89492
89493   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89494   {
89495     try {
89496       delete arg1;
89497     } catch (std::out_of_range& e) {
89498       {
89499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89500       };
89501     } catch (std::exception& e) {
89502       {
89503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89504       };
89505     } catch (Dali::DaliException e) {
89506       {
89507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89508       };
89509     } catch (...) {
89510       {
89511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89512       };
89513     }
89514   }
89515
89516 }
89517
89518
89519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
89520   void * jresult ;
89521   Dali::Toolkit::PageFactory *arg1 = 0 ;
89522   Dali::Vector2 *arg2 = 0 ;
89523   Dali::Toolkit::PageTurnPortraitView result;
89524
89525   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89526   if (!arg1) {
89527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
89528     return 0;
89529   }
89530   arg2 = (Dali::Vector2 *)jarg2;
89531   if (!arg2) {
89532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
89533     return 0;
89534   }
89535   {
89536     try {
89537       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
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 = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
89558   return jresult;
89559 }
89560
89561
89562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
89563   void * jresult ;
89564   Dali::BaseHandle arg1 ;
89565   Dali::BaseHandle *argp1 ;
89566   Dali::Toolkit::PageTurnPortraitView result;
89567
89568   argp1 = (Dali::BaseHandle *)jarg1;
89569   if (!argp1) {
89570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89571     return 0;
89572   }
89573   arg1 = *argp1;
89574   {
89575     try {
89576       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
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 = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
89597   return jresult;
89598 }
89599
89600
89601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
89602   int jresult ;
89603   int result;
89604
89605   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
89606   jresult = (int)result;
89607   return jresult;
89608 }
89609
89610
89611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
89612   int jresult ;
89613   int result;
89614
89615   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
89616   jresult = (int)result;
89617   return jresult;
89618 }
89619
89620
89621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
89622   int jresult ;
89623   int result;
89624
89625   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
89626   jresult = (int)result;
89627   return jresult;
89628 }
89629
89630
89631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
89632   void * jresult ;
89633   Dali::Toolkit::ToggleButton::Property *result = 0 ;
89634
89635   {
89636     try {
89637       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
89638     } catch (std::out_of_range& e) {
89639       {
89640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89641       };
89642     } catch (std::exception& e) {
89643       {
89644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89645       };
89646     } catch (Dali::DaliException e) {
89647       {
89648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89649       };
89650     } catch (...) {
89651       {
89652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89653       };
89654     }
89655   }
89656
89657   jresult = (void *)result;
89658   return jresult;
89659 }
89660
89661
89662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
89663   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
89664
89665   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
89666   {
89667     try {
89668       delete arg1;
89669     } catch (std::out_of_range& e) {
89670       {
89671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89672       };
89673     } catch (std::exception& e) {
89674       {
89675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89676       };
89677     } catch (Dali::DaliException e) {
89678       {
89679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89680       };
89681     } catch (...) {
89682       {
89683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89684       };
89685     }
89686   }
89687
89688 }
89689
89690
89691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
89692   void * jresult ;
89693   Dali::Toolkit::ToggleButton *result = 0 ;
89694
89695   {
89696     try {
89697       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
89698     } catch (std::out_of_range& e) {
89699       {
89700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89701       };
89702     } catch (std::exception& e) {
89703       {
89704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89705       };
89706     } catch (Dali::DaliException e) {
89707       {
89708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89709       };
89710     } catch (...) {
89711       {
89712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89713       };
89714     }
89715   }
89716
89717   jresult = (void *)result;
89718   return jresult;
89719 }
89720
89721
89722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
89723   void * jresult ;
89724   Dali::Toolkit::ToggleButton *arg1 = 0 ;
89725   Dali::Toolkit::ToggleButton *result = 0 ;
89726
89727   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89728   if (!arg1) {
89729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
89730     return 0;
89731   }
89732   {
89733     try {
89734       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
89735     } catch (std::out_of_range& e) {
89736       {
89737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89738       };
89739     } catch (std::exception& e) {
89740       {
89741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89742       };
89743     } catch (Dali::DaliException e) {
89744       {
89745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89746       };
89747     } catch (...) {
89748       {
89749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89750       };
89751     }
89752   }
89753
89754   jresult = (void *)result;
89755   return jresult;
89756 }
89757
89758
89759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
89760   void * jresult ;
89761   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
89762   Dali::Toolkit::ToggleButton *arg2 = 0 ;
89763   Dali::Toolkit::ToggleButton *result = 0 ;
89764
89765   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89766   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
89767   if (!arg2) {
89768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
89769     return 0;
89770   }
89771   {
89772     try {
89773       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
89774     } catch (std::out_of_range& e) {
89775       {
89776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89777       };
89778     } catch (std::exception& e) {
89779       {
89780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89781       };
89782     } catch (Dali::DaliException e) {
89783       {
89784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89785       };
89786     } catch (...) {
89787       {
89788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89789       };
89790     }
89791   }
89792
89793   jresult = (void *)result;
89794   return jresult;
89795 }
89796
89797
89798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
89799   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
89800
89801   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89802   {
89803     try {
89804       delete arg1;
89805     } catch (std::out_of_range& e) {
89806       {
89807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89808       };
89809     } catch (std::exception& e) {
89810       {
89811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89812       };
89813     } catch (Dali::DaliException e) {
89814       {
89815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89816       };
89817     } catch (...) {
89818       {
89819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89820       };
89821     }
89822   }
89823
89824 }
89825
89826
89827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
89828   void * jresult ;
89829   Dali::Toolkit::ToggleButton result;
89830
89831   {
89832     try {
89833       result = Dali::Toolkit::ToggleButton::New();
89834     } catch (std::out_of_range& e) {
89835       {
89836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89837       };
89838     } catch (std::exception& e) {
89839       {
89840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89841       };
89842     } catch (Dali::DaliException e) {
89843       {
89844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89845       };
89846     } catch (...) {
89847       {
89848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89849       };
89850     }
89851   }
89852
89853   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
89854   return jresult;
89855 }
89856
89857
89858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
89859   void * jresult ;
89860   Dali::BaseHandle arg1 ;
89861   Dali::BaseHandle *argp1 ;
89862   Dali::Toolkit::ToggleButton result;
89863
89864   argp1 = (Dali::BaseHandle *)jarg1;
89865   if (!argp1) {
89866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89867     return 0;
89868   }
89869   arg1 = *argp1;
89870   {
89871     try {
89872       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
89873     } catch (std::out_of_range& e) {
89874       {
89875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89876       };
89877     } catch (std::exception& e) {
89878       {
89879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89880       };
89881     } catch (Dali::DaliException e) {
89882       {
89883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89884       };
89885     } catch (...) {
89886       {
89887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89888       };
89889     }
89890   }
89891
89892   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
89893   return jresult;
89894 }
89895
89896
89897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
89898   void * jresult ;
89899   Dali::Toolkit::Visual::Base *result = 0 ;
89900
89901   {
89902     try {
89903       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
89904     } catch (std::out_of_range& e) {
89905       {
89906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89907       };
89908     } catch (std::exception& e) {
89909       {
89910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89911       };
89912     } catch (Dali::DaliException e) {
89913       {
89914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89915       };
89916     } catch (...) {
89917       {
89918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89919       };
89920     }
89921   }
89922
89923   jresult = (void *)result;
89924   return jresult;
89925 }
89926
89927
89928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
89929   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89930
89931   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89932   {
89933     try {
89934       delete arg1;
89935     } catch (std::out_of_range& e) {
89936       {
89937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89938       };
89939     } catch (std::exception& e) {
89940       {
89941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89942       };
89943     } catch (Dali::DaliException e) {
89944       {
89945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89946       };
89947     } catch (...) {
89948       {
89949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89950       };
89951     }
89952   }
89953
89954 }
89955
89956
89957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
89958   void * jresult ;
89959   Dali::Toolkit::Visual::Base *arg1 = 0 ;
89960   Dali::Toolkit::Visual::Base *result = 0 ;
89961
89962   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89963   if (!arg1) {
89964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
89965     return 0;
89966   }
89967   {
89968     try {
89969       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
89970     } catch (std::out_of_range& e) {
89971       {
89972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89973       };
89974     } catch (std::exception& e) {
89975       {
89976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89977       };
89978     } catch (Dali::DaliException e) {
89979       {
89980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89981       };
89982     } catch (...) {
89983       {
89984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89985       };
89986     }
89987   }
89988
89989   jresult = (void *)result;
89990   return jresult;
89991 }
89992
89993
89994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
89995   void * jresult ;
89996   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89997   Dali::Toolkit::Visual::Base *arg2 = 0 ;
89998   Dali::Toolkit::Visual::Base *result = 0 ;
89999
90000   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90001   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
90002   if (!arg2) {
90003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
90004     return 0;
90005   }
90006   {
90007     try {
90008       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
90009     } catch (std::out_of_range& e) {
90010       {
90011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90012       };
90013     } catch (std::exception& e) {
90014       {
90015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90016       };
90017     } catch (Dali::DaliException e) {
90018       {
90019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90020       };
90021     } catch (...) {
90022       {
90023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90024       };
90025     }
90026   }
90027
90028   jresult = (void *)result;
90029   return jresult;
90030 }
90031
90032
90033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
90034   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90035   std::string *arg2 = 0 ;
90036
90037   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90038   if (!jarg2) {
90039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90040     return ;
90041   }
90042   std::string arg2_str(jarg2);
90043   arg2 = &arg2_str;
90044   {
90045     try {
90046       (arg1)->SetName((std::string const &)*arg2);
90047     } catch (std::out_of_range& e) {
90048       {
90049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90050       };
90051     } catch (std::exception& e) {
90052       {
90053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90054       };
90055     } catch (Dali::DaliException e) {
90056       {
90057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90058       };
90059     } catch (...) {
90060       {
90061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90062       };
90063     }
90064   }
90065
90066
90067   //argout typemap for const std::string&
90068
90069 }
90070
90071
90072 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
90073   char * jresult ;
90074   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90075   std::string *result = 0 ;
90076
90077   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90078   {
90079     try {
90080       result = (std::string *) &(arg1)->GetName();
90081     } catch (std::out_of_range& e) {
90082       {
90083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90084       };
90085     } catch (std::exception& e) {
90086       {
90087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90088       };
90089     } catch (Dali::DaliException e) {
90090       {
90091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90092       };
90093     } catch (...) {
90094       {
90095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90096       };
90097     }
90098   }
90099
90100   jresult = SWIG_csharp_string_callback(result->c_str());
90101   return jresult;
90102 }
90103
90104
90105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
90106   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90107   Dali::Property::Map *arg2 = 0 ;
90108   Dali::Size arg3 ;
90109   Dali::Size *argp3 ;
90110
90111   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90112   arg2 = (Dali::Property::Map *)jarg2;
90113   if (!arg2) {
90114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
90115     return ;
90116   }
90117   argp3 = (Dali::Size *)jarg3;
90118   if (!argp3) {
90119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
90120     return ;
90121   }
90122   arg3 = *argp3;
90123   {
90124     try {
90125       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
90126     } catch (std::out_of_range& e) {
90127       {
90128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90129       };
90130     } catch (std::exception& e) {
90131       {
90132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90133       };
90134     } catch (Dali::DaliException e) {
90135       {
90136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90137       };
90138     } catch (...) {
90139       {
90140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90141       };
90142     }
90143   }
90144
90145 }
90146
90147
90148 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
90149   float jresult ;
90150   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90151   float arg2 ;
90152   float result;
90153
90154   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90155   arg2 = (float)jarg2;
90156   {
90157     try {
90158       result = (float)(arg1)->GetHeightForWidth(arg2);
90159     } catch (std::out_of_range& e) {
90160       {
90161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90162       };
90163     } catch (std::exception& e) {
90164       {
90165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90166       };
90167     } catch (Dali::DaliException e) {
90168       {
90169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90170       };
90171     } catch (...) {
90172       {
90173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90174       };
90175     }
90176   }
90177
90178   jresult = result;
90179   return jresult;
90180 }
90181
90182
90183 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
90184   float jresult ;
90185   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90186   float arg2 ;
90187   float result;
90188
90189   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90190   arg2 = (float)jarg2;
90191   {
90192     try {
90193       result = (float)(arg1)->GetWidthForHeight(arg2);
90194     } catch (std::out_of_range& e) {
90195       {
90196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90197       };
90198     } catch (std::exception& e) {
90199       {
90200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90201       };
90202     } catch (Dali::DaliException e) {
90203       {
90204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90205       };
90206     } catch (...) {
90207       {
90208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90209       };
90210     }
90211   }
90212
90213   jresult = result;
90214   return jresult;
90215 }
90216
90217
90218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
90219   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90220   Dali::Vector2 *arg2 = 0 ;
90221
90222   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90223   arg2 = (Dali::Vector2 *)jarg2;
90224   if (!arg2) {
90225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
90226     return ;
90227   }
90228   {
90229     try {
90230       (arg1)->GetNaturalSize(*arg2);
90231     } catch (std::out_of_range& e) {
90232       {
90233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90234       };
90235     } catch (std::exception& e) {
90236       {
90237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90238       };
90239     } catch (Dali::DaliException e) {
90240       {
90241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90242       };
90243     } catch (...) {
90244       {
90245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90246       };
90247     }
90248   }
90249
90250 }
90251
90252
90253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
90254   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90255   float arg2 ;
90256
90257   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90258   arg2 = (int)jarg2;
90259   {
90260     try {
90261       (arg1)->SetDepthIndex(arg2);
90262     } catch (std::out_of_range& e) {
90263       {
90264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90265       };
90266     } catch (std::exception& e) {
90267       {
90268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90269       };
90270     } catch (Dali::DaliException e) {
90271       {
90272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90273       };
90274     } catch (...) {
90275       {
90276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90277       };
90278     }
90279   }
90280
90281 }
90282
90283
90284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
90285   int jresult ;
90286   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90287   int result;
90288
90289   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90290   {
90291     try {
90292       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
90293     } catch (std::out_of_range& e) {
90294       {
90295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90296       };
90297     } catch (std::exception& e) {
90298       {
90299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90300       };
90301     } catch (Dali::DaliException e) {
90302       {
90303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90304       };
90305     } catch (...) {
90306       {
90307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90308       };
90309     }
90310   }
90311
90312   jresult = result;
90313   return jresult;
90314 }
90315
90316
90317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
90318   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90319   Dali::Property::Map *arg2 = 0 ;
90320
90321   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90322   arg2 = (Dali::Property::Map *)jarg2;
90323   if (!arg2) {
90324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
90325     return ;
90326   }
90327   {
90328     try {
90329       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
90330     } catch (std::out_of_range& e) {
90331       {
90332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90333       };
90334     } catch (std::exception& e) {
90335       {
90336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90337       };
90338     } catch (Dali::DaliException e) {
90339       {
90340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90341       };
90342     } catch (...) {
90343       {
90344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90345       };
90346     }
90347   }
90348
90349 }
90350
90351
90352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
90353   void * jresult ;
90354   Dali::Toolkit::VisualFactory result;
90355
90356   {
90357     try {
90358       result = Dali::Toolkit::VisualFactory::Get();
90359     } catch (std::out_of_range& e) {
90360       {
90361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90362       };
90363     } catch (std::exception& e) {
90364       {
90365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90366       };
90367     } catch (Dali::DaliException e) {
90368       {
90369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90370       };
90371     } catch (...) {
90372       {
90373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90374       };
90375     }
90376   }
90377
90378   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
90379   return jresult;
90380 }
90381
90382
90383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
90384   void * jresult ;
90385   Dali::Toolkit::VisualFactory *result = 0 ;
90386
90387   {
90388     try {
90389       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
90390     } catch (std::out_of_range& e) {
90391       {
90392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90393       };
90394     } catch (std::exception& e) {
90395       {
90396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90397       };
90398     } catch (Dali::DaliException e) {
90399       {
90400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90401       };
90402     } catch (...) {
90403       {
90404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90405       };
90406     }
90407   }
90408
90409   jresult = (void *)result;
90410   return jresult;
90411 }
90412
90413
90414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
90415   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90416
90417   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90418   {
90419     try {
90420       delete arg1;
90421     } catch (std::out_of_range& e) {
90422       {
90423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90424       };
90425     } catch (std::exception& e) {
90426       {
90427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90428       };
90429     } catch (Dali::DaliException e) {
90430       {
90431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90432       };
90433     } catch (...) {
90434       {
90435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90436       };
90437     }
90438   }
90439
90440 }
90441
90442
90443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
90444   void * jresult ;
90445   Dali::Toolkit::VisualFactory *arg1 = 0 ;
90446   Dali::Toolkit::VisualFactory *result = 0 ;
90447
90448   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90449   if (!arg1) {
90450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
90451     return 0;
90452   }
90453   {
90454     try {
90455       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
90456     } catch (std::out_of_range& e) {
90457       {
90458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90459       };
90460     } catch (std::exception& e) {
90461       {
90462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90463       };
90464     } catch (Dali::DaliException e) {
90465       {
90466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90467       };
90468     } catch (...) {
90469       {
90470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90471       };
90472     }
90473   }
90474
90475   jresult = (void *)result;
90476   return jresult;
90477 }
90478
90479
90480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
90481   void * jresult ;
90482   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90483   Dali::Toolkit::VisualFactory *arg2 = 0 ;
90484   Dali::Toolkit::VisualFactory *result = 0 ;
90485
90486   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90487   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
90488   if (!arg2) {
90489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
90490     return 0;
90491   }
90492   {
90493     try {
90494       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
90495     } catch (std::out_of_range& e) {
90496       {
90497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90498       };
90499     } catch (std::exception& e) {
90500       {
90501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90502       };
90503     } catch (Dali::DaliException e) {
90504       {
90505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90506       };
90507     } catch (...) {
90508       {
90509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90510       };
90511     }
90512   }
90513
90514   jresult = (void *)result;
90515   return jresult;
90516 }
90517
90518
90519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
90520   void * jresult ;
90521   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90522   Dali::Property::Map *arg2 = 0 ;
90523   Dali::Toolkit::Visual::Base result;
90524
90525   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90526   arg2 = (Dali::Property::Map *)jarg2;
90527   if (!arg2) {
90528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
90529     return 0;
90530   }
90531   {
90532     try {
90533       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
90534     } catch (std::out_of_range& e) {
90535       {
90536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90537       };
90538     } catch (std::exception& e) {
90539       {
90540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90541       };
90542     } catch (Dali::DaliException e) {
90543       {
90544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90545       };
90546     } catch (...) {
90547       {
90548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90549       };
90550     }
90551   }
90552
90553   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90554   return jresult;
90555 }
90556
90557
90558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
90559   void * jresult ;
90560   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90561   Dali::Image *arg2 = 0 ;
90562   Dali::Toolkit::Visual::Base result;
90563
90564   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90565   arg2 = (Dali::Image *)jarg2;
90566   if (!arg2) {
90567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
90568     return 0;
90569   }
90570   {
90571     try {
90572       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
90573     } catch (std::out_of_range& e) {
90574       {
90575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90576       };
90577     } catch (std::exception& e) {
90578       {
90579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90580       };
90581     } catch (Dali::DaliException e) {
90582       {
90583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90584       };
90585     } catch (...) {
90586       {
90587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90588       };
90589     }
90590   }
90591
90592   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90593   return jresult;
90594 }
90595
90596
90597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
90598   void * jresult ;
90599   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90600   std::string *arg2 = 0 ;
90601   Dali::ImageDimensions arg3 ;
90602   Dali::ImageDimensions *argp3 ;
90603   Dali::Toolkit::Visual::Base result;
90604
90605   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90606   if (!jarg2) {
90607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90608     return 0;
90609   }
90610   std::string arg2_str(jarg2);
90611   arg2 = &arg2_str;
90612   argp3 = (Dali::ImageDimensions *)jarg3;
90613   if (!argp3) {
90614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90615     return 0;
90616   }
90617   arg3 = *argp3;
90618   {
90619     try {
90620       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
90621     } catch (std::out_of_range& e) {
90622       {
90623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90624       };
90625     } catch (std::exception& e) {
90626       {
90627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90628       };
90629     } catch (Dali::DaliException e) {
90630       {
90631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90632       };
90633     } catch (...) {
90634       {
90635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90636       };
90637     }
90638   }
90639
90640   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90641
90642   //argout typemap for const std::string&
90643
90644   return jresult;
90645 }
90646
90647
90648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
90649   void * jresult ;
90650   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90651
90652   {
90653     try {
90654       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
90655     } catch (std::out_of_range& e) {
90656       {
90657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90658       };
90659     } catch (std::exception& e) {
90660       {
90661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90662       };
90663     } catch (Dali::DaliException e) {
90664       {
90665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90666       };
90667     } catch (...) {
90668       {
90669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90670       };
90671     }
90672   }
90673
90674   jresult = (void *)result;
90675   return jresult;
90676 }
90677
90678
90679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
90680   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90681
90682   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90683   {
90684     try {
90685       delete arg1;
90686     } catch (std::out_of_range& e) {
90687       {
90688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90689       };
90690     } catch (std::exception& e) {
90691       {
90692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90693       };
90694     } catch (Dali::DaliException e) {
90695       {
90696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90697       };
90698     } catch (...) {
90699       {
90700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90701       };
90702     }
90703   }
90704
90705 }
90706
90707
90708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
90709   void * jresult ;
90710   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
90711   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90712
90713   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90714   if (!arg1) {
90715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
90716     return 0;
90717   }
90718   {
90719     try {
90720       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
90721     } catch (std::out_of_range& e) {
90722       {
90723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90724       };
90725     } catch (std::exception& e) {
90726       {
90727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90728       };
90729     } catch (Dali::DaliException e) {
90730       {
90731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90732       };
90733     } catch (...) {
90734       {
90735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90736       };
90737     }
90738   }
90739
90740   jresult = (void *)result;
90741   return jresult;
90742 }
90743
90744
90745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
90746   void * jresult ;
90747   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90748   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
90749   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90750
90751   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90752   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
90753   if (!arg2) {
90754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
90755     return 0;
90756   }
90757   {
90758     try {
90759       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
90760     } catch (std::out_of_range& e) {
90761       {
90762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90763       };
90764     } catch (std::exception& e) {
90765       {
90766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90767       };
90768     } catch (Dali::DaliException e) {
90769       {
90770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90771       };
90772     } catch (...) {
90773       {
90774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90775       };
90776     }
90777   }
90778
90779   jresult = (void *)result;
90780   return jresult;
90781 }
90782
90783
90784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
90785   void * jresult ;
90786   Dali::Toolkit::AsyncImageLoader result;
90787
90788   {
90789     try {
90790       result = Dali::Toolkit::AsyncImageLoader::New();
90791     } catch (std::out_of_range& e) {
90792       {
90793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90794       };
90795     } catch (std::exception& e) {
90796       {
90797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90798       };
90799     } catch (Dali::DaliException e) {
90800       {
90801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90802       };
90803     } catch (...) {
90804       {
90805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90806       };
90807     }
90808   }
90809
90810   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
90811   return jresult;
90812 }
90813
90814
90815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
90816   void * jresult ;
90817   Dali::BaseHandle arg1 ;
90818   Dali::BaseHandle *argp1 ;
90819   Dali::Toolkit::AsyncImageLoader result;
90820
90821   argp1 = (Dali::BaseHandle *)jarg1;
90822   if (!argp1) {
90823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90824     return 0;
90825   }
90826   arg1 = *argp1;
90827   {
90828     try {
90829       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
90830     } catch (std::out_of_range& e) {
90831       {
90832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90833       };
90834     } catch (std::exception& e) {
90835       {
90836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90837       };
90838     } catch (Dali::DaliException e) {
90839       {
90840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90841       };
90842     } catch (...) {
90843       {
90844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90845       };
90846     }
90847   }
90848
90849   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
90850   return jresult;
90851 }
90852
90853
90854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
90855   unsigned int jresult ;
90856   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90857   std::string *arg2 = 0 ;
90858   uint32_t result;
90859
90860   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90861   if (!jarg2) {
90862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90863     return 0;
90864   }
90865   std::string arg2_str(jarg2);
90866   arg2 = &arg2_str;
90867   {
90868     try {
90869       result = (arg1)->Load((std::string const &)*arg2);
90870     } catch (std::out_of_range& e) {
90871       {
90872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90873       };
90874     } catch (std::exception& e) {
90875       {
90876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90877       };
90878     } catch (Dali::DaliException e) {
90879       {
90880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90881       };
90882     } catch (...) {
90883       {
90884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90885       };
90886     }
90887   }
90888
90889   jresult = result;
90890
90891   //argout typemap for const std::string&
90892
90893   return jresult;
90894 }
90895
90896
90897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
90898   unsigned int jresult ;
90899   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90900   std::string *arg2 = 0 ;
90901   Dali::ImageDimensions arg3 ;
90902   Dali::ImageDimensions *argp3 ;
90903   uint32_t result;
90904
90905   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90906   if (!jarg2) {
90907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90908     return 0;
90909   }
90910   std::string arg2_str(jarg2);
90911   arg2 = &arg2_str;
90912   argp3 = (Dali::ImageDimensions *)jarg3;
90913   if (!argp3) {
90914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90915     return 0;
90916   }
90917   arg3 = *argp3;
90918   {
90919     try {
90920       result = (arg1)->Load((std::string const &)*arg2,arg3);
90921     } catch (std::out_of_range& e) {
90922       {
90923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90924       };
90925     } catch (std::exception& e) {
90926       {
90927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90928       };
90929     } catch (Dali::DaliException e) {
90930       {
90931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90932       };
90933     } catch (...) {
90934       {
90935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90936       };
90937     }
90938   }
90939
90940   jresult = result;
90941
90942   //argout typemap for const std::string&
90943
90944   return jresult;
90945 }
90946
90947
90948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
90949   unsigned int jresult ;
90950   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90951   std::string *arg2 = 0 ;
90952   Dali::ImageDimensions arg3 ;
90953   Dali::FittingMode::Type arg4 ;
90954   Dali::SamplingMode::Type arg5 ;
90955   bool arg6 ;
90956   Dali::ImageDimensions *argp3 ;
90957   uint32_t result;
90958
90959   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90960   if (!jarg2) {
90961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90962     return 0;
90963   }
90964   std::string arg2_str(jarg2);
90965   arg2 = &arg2_str;
90966   argp3 = (Dali::ImageDimensions *)jarg3;
90967   if (!argp3) {
90968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90969     return 0;
90970   }
90971   arg3 = *argp3;
90972   arg4 = (Dali::FittingMode::Type)jarg4;
90973   arg5 = (Dali::SamplingMode::Type)jarg5;
90974   arg6 = jarg6 ? true : false;
90975   {
90976     try {
90977       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
90978     } catch (std::out_of_range& e) {
90979       {
90980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90981       };
90982     } catch (std::exception& e) {
90983       {
90984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90985       };
90986     } catch (Dali::DaliException e) {
90987       {
90988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90989       };
90990     } catch (...) {
90991       {
90992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90993       };
90994     }
90995   }
90996
90997   jresult = result;
90998
90999   //argout typemap for const std::string&
91000
91001   return jresult;
91002 }
91003
91004
91005 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
91006   unsigned int jresult ;
91007   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91008   uint32_t arg2 ;
91009   bool result;
91010
91011   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91012   arg2 = (uint32_t)jarg2;
91013   {
91014     try {
91015       result = (bool)(arg1)->Cancel(arg2);
91016     } catch (std::out_of_range& e) {
91017       {
91018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91019       };
91020     } catch (std::exception& e) {
91021       {
91022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91023       };
91024     } catch (Dali::DaliException e) {
91025       {
91026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91027       };
91028     } catch (...) {
91029       {
91030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91031       };
91032     }
91033   }
91034
91035   jresult = result;
91036   return jresult;
91037 }
91038
91039
91040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
91041   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91042
91043   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91044   {
91045     try {
91046       (arg1)->CancelAll();
91047     } catch (std::out_of_range& e) {
91048       {
91049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91050       };
91051     } catch (std::exception& e) {
91052       {
91053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91054       };
91055     } catch (Dali::DaliException e) {
91056       {
91057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91058       };
91059     } catch (...) {
91060       {
91061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91062       };
91063     }
91064   }
91065
91066 }
91067
91068
91069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
91070   void * jresult ;
91071   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91072   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
91073
91074   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91075   {
91076     try {
91077       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
91078     } catch (std::out_of_range& e) {
91079       {
91080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91081       };
91082     } catch (std::exception& e) {
91083       {
91084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91085       };
91086     } catch (Dali::DaliException e) {
91087       {
91088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91089       };
91090     } catch (...) {
91091       {
91092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91093       };
91094     }
91095   }
91096
91097   jresult = (void *)result;
91098   return jresult;
91099 }
91100
91101
91102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
91103   void * jresult ;
91104   std::string *arg1 = 0 ;
91105   Dali::PixelData result;
91106
91107   if (!jarg1) {
91108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91109     return 0;
91110   }
91111   std::string arg1_str(jarg1);
91112   arg1 = &arg1_str;
91113   {
91114     try {
91115       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
91116     } catch (std::out_of_range& e) {
91117       {
91118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91119       };
91120     } catch (std::exception& e) {
91121       {
91122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91123       };
91124     } catch (Dali::DaliException e) {
91125       {
91126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91127       };
91128     } catch (...) {
91129       {
91130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91131       };
91132     }
91133   }
91134
91135   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91136
91137   //argout typemap for const std::string&
91138
91139   return jresult;
91140 }
91141
91142
91143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
91144   void * jresult ;
91145   std::string *arg1 = 0 ;
91146   Dali::ImageDimensions arg2 ;
91147   Dali::ImageDimensions *argp2 ;
91148   Dali::PixelData result;
91149
91150   if (!jarg1) {
91151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91152     return 0;
91153   }
91154   std::string arg1_str(jarg1);
91155   arg1 = &arg1_str;
91156   argp2 = (Dali::ImageDimensions *)jarg2;
91157   if (!argp2) {
91158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91159     return 0;
91160   }
91161   arg2 = *argp2;
91162   {
91163     try {
91164       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
91165     } catch (std::out_of_range& e) {
91166       {
91167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91168       };
91169     } catch (std::exception& e) {
91170       {
91171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91172       };
91173     } catch (Dali::DaliException e) {
91174       {
91175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91176       };
91177     } catch (...) {
91178       {
91179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91180       };
91181     }
91182   }
91183
91184   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91185
91186   //argout typemap for const std::string&
91187
91188   return jresult;
91189 }
91190
91191
91192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
91193   void * jresult ;
91194   std::string *arg1 = 0 ;
91195   Dali::ImageDimensions arg2 ;
91196   Dali::FittingMode::Type arg3 ;
91197   Dali::SamplingMode::Type arg4 ;
91198   bool arg5 ;
91199   Dali::ImageDimensions *argp2 ;
91200   Dali::PixelData result;
91201
91202   if (!jarg1) {
91203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91204     return 0;
91205   }
91206   std::string arg1_str(jarg1);
91207   arg1 = &arg1_str;
91208   argp2 = (Dali::ImageDimensions *)jarg2;
91209   if (!argp2) {
91210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91211     return 0;
91212   }
91213   arg2 = *argp2;
91214   arg3 = (Dali::FittingMode::Type)jarg3;
91215   arg4 = (Dali::SamplingMode::Type)jarg4;
91216   arg5 = jarg5 ? true : false;
91217   {
91218     try {
91219       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
91220     } catch (std::out_of_range& e) {
91221       {
91222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91223       };
91224     } catch (std::exception& e) {
91225       {
91226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91227       };
91228     } catch (Dali::DaliException e) {
91229       {
91230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91231       };
91232     } catch (...) {
91233       {
91234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91235       };
91236     }
91237   }
91238
91239   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91240
91241   //argout typemap for const std::string&
91242
91243   return jresult;
91244 }
91245
91246
91247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
91248   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
91249
91250   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
91251   {
91252     try {
91253       delete arg1;
91254     } catch (std::out_of_range& e) {
91255       {
91256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91257       };
91258     } catch (std::exception& e) {
91259       {
91260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91261       };
91262     } catch (Dali::DaliException e) {
91263       {
91264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91265       };
91266     } catch (...) {
91267       {
91268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91269       };
91270     }
91271   }
91272
91273 }
91274
91275
91276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
91277   void * jresult ;
91278   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
91279   Dali::Actor arg2 ;
91280   Dali::Actor arg3 ;
91281   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
91282   Dali::Actor *argp2 ;
91283   Dali::Actor *argp3 ;
91284   Dali::Actor result;
91285
91286   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
91287   argp2 = (Dali::Actor *)jarg2;
91288   if (!argp2) {
91289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91290     return 0;
91291   }
91292   arg2 = *argp2;
91293   argp3 = (Dali::Actor *)jarg3;
91294   if (!argp3) {
91295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91296     return 0;
91297   }
91298   arg3 = *argp3;
91299   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
91300   {
91301     try {
91302       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
91303     } catch (std::out_of_range& e) {
91304       {
91305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91306       };
91307     } catch (std::exception& e) {
91308       {
91309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91310       };
91311     } catch (Dali::DaliException e) {
91312       {
91313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91314       };
91315     } catch (...) {
91316       {
91317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91318       };
91319     }
91320   }
91321
91322   jresult = new Dali::Actor((const Dali::Actor &)result);
91323   return jresult;
91324 }
91325
91326
91327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
91328   void * jresult ;
91329   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
91330
91331   {
91332     try {
91333       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
91334     } catch (std::out_of_range& e) {
91335       {
91336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91337       };
91338     } catch (std::exception& e) {
91339       {
91340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91341       };
91342     } catch (Dali::DaliException e) {
91343       {
91344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91345       };
91346     } catch (...) {
91347       {
91348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91349       };
91350     }
91351   }
91352
91353   jresult = (void *)result;
91354   return jresult;
91355 }
91356
91357
91358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
91359   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
91360   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
91361   if (director) {
91362     director->swig_connect_director(callback0);
91363   }
91364 }
91365
91366
91367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
91368   KeyboardFocusManager arg1 ;
91369   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
91370   KeyboardFocusManager *argp1 ;
91371
91372   argp1 = (KeyboardFocusManager *)jarg1;
91373   if (!argp1) {
91374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
91375     return ;
91376   }
91377   arg1 = *argp1;
91378   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
91379   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
91380   {
91381     try {
91382       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
91383     } catch (std::out_of_range& e) {
91384       {
91385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91386       };
91387     } catch (std::exception& e) {
91388       {
91389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91390       };
91391     } catch (Dali::DaliException e) {
91392       {
91393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91394       };
91395     } catch (...) {
91396       {
91397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91398       };
91399     }
91400   }
91401
91402 }
91403
91404
91405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
91406   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91407
91408   arg1 = (std::vector< unsigned int > *)jarg1;
91409   {
91410     try {
91411       (arg1)->clear();
91412     } catch (std::out_of_range& e) {
91413       {
91414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91415       };
91416     } catch (std::exception& e) {
91417       {
91418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91419       };
91420     } catch (Dali::DaliException e) {
91421       {
91422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91423       };
91424     } catch (...) {
91425       {
91426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91427       };
91428     }
91429   }
91430
91431 }
91432
91433
91434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
91435   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91436   unsigned int *arg2 = 0 ;
91437   unsigned int temp2 ;
91438
91439   arg1 = (std::vector< unsigned int > *)jarg1;
91440   temp2 = (unsigned int)jarg2;
91441   arg2 = &temp2;
91442   {
91443     try {
91444       (arg1)->push_back((unsigned int const &)*arg2);
91445     } catch (std::out_of_range& e) {
91446       {
91447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91448       };
91449     } catch (std::exception& e) {
91450       {
91451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91452       };
91453     } catch (Dali::DaliException e) {
91454       {
91455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91456       };
91457     } catch (...) {
91458       {
91459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91460       };
91461     }
91462   }
91463
91464 }
91465
91466
91467 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
91468   unsigned long jresult ;
91469   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91470   std::vector< unsigned int >::size_type result;
91471
91472   arg1 = (std::vector< unsigned int > *)jarg1;
91473   {
91474     try {
91475       result = ((std::vector< unsigned int > const *)arg1)->size();
91476     } catch (std::out_of_range& e) {
91477       {
91478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91479       };
91480     } catch (std::exception& e) {
91481       {
91482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91483       };
91484     } catch (Dali::DaliException e) {
91485       {
91486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91487       };
91488     } catch (...) {
91489       {
91490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91491       };
91492     }
91493   }
91494
91495   jresult = (unsigned long)result;
91496   return jresult;
91497 }
91498
91499
91500 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
91501   unsigned long jresult ;
91502   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91503   std::vector< unsigned int >::size_type result;
91504
91505   arg1 = (std::vector< unsigned int > *)jarg1;
91506   {
91507     try {
91508       result = ((std::vector< unsigned int > const *)arg1)->capacity();
91509     } catch (std::out_of_range& e) {
91510       {
91511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91512       };
91513     } catch (std::exception& e) {
91514       {
91515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91516       };
91517     } catch (Dali::DaliException e) {
91518       {
91519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91520       };
91521     } catch (...) {
91522       {
91523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91524       };
91525     }
91526   }
91527
91528   jresult = (unsigned long)result;
91529   return jresult;
91530 }
91531
91532
91533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
91534   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91535   std::vector< unsigned int >::size_type arg2 ;
91536
91537   arg1 = (std::vector< unsigned int > *)jarg1;
91538   arg2 = (std::vector< unsigned int >::size_type)jarg2;
91539   {
91540     try {
91541       (arg1)->reserve(arg2);
91542     } catch (std::out_of_range& e) {
91543       {
91544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91545       };
91546     } catch (std::exception& e) {
91547       {
91548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91549       };
91550     } catch (Dali::DaliException e) {
91551       {
91552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91553       };
91554     } catch (...) {
91555       {
91556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91557       };
91558     }
91559   }
91560
91561 }
91562
91563
91564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
91565   void * jresult ;
91566   std::vector< unsigned int > *result = 0 ;
91567
91568   {
91569     try {
91570       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
91571     } catch (std::out_of_range& e) {
91572       {
91573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91574       };
91575     } catch (std::exception& e) {
91576       {
91577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91578       };
91579     } catch (Dali::DaliException e) {
91580       {
91581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91582       };
91583     } catch (...) {
91584       {
91585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91586       };
91587     }
91588   }
91589
91590   jresult = (void *)result;
91591   return jresult;
91592 }
91593
91594
91595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
91596   void * jresult ;
91597   std::vector< unsigned int > *arg1 = 0 ;
91598   std::vector< unsigned int > *result = 0 ;
91599
91600   arg1 = (std::vector< unsigned int > *)jarg1;
91601   if (!arg1) {
91602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91603     return 0;
91604   }
91605   {
91606     try {
91607       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
91608     } catch (std::out_of_range& e) {
91609       {
91610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91611       };
91612     } catch (std::exception& e) {
91613       {
91614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91615       };
91616     } catch (Dali::DaliException e) {
91617       {
91618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91619       };
91620     } catch (...) {
91621       {
91622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91623       };
91624     }
91625   }
91626
91627   jresult = (void *)result;
91628   return jresult;
91629 }
91630
91631
91632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
91633   void * jresult ;
91634   int arg1 ;
91635   std::vector< unsigned int > *result = 0 ;
91636
91637   arg1 = (int)jarg1;
91638   {
91639     try {
91640       try {
91641         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
91642       }
91643       catch(std::out_of_range &_e) {
91644         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91645         return 0;
91646       }
91647
91648     } catch (std::out_of_range& e) {
91649       {
91650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91651       };
91652     } catch (std::exception& e) {
91653       {
91654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91655       };
91656     } catch (Dali::DaliException e) {
91657       {
91658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91659       };
91660     } catch (...) {
91661       {
91662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91663       };
91664     }
91665   }
91666
91667   jresult = (void *)result;
91668   return jresult;
91669 }
91670
91671
91672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
91673   unsigned int jresult ;
91674   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91675   int arg2 ;
91676   unsigned int result;
91677
91678   arg1 = (std::vector< unsigned int > *)jarg1;
91679   arg2 = (int)jarg2;
91680   {
91681     try {
91682       try {
91683         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
91684       }
91685       catch(std::out_of_range &_e) {
91686         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91687         return 0;
91688       }
91689
91690     } catch (std::out_of_range& e) {
91691       {
91692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91693       };
91694     } catch (std::exception& e) {
91695       {
91696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91697       };
91698     } catch (Dali::DaliException e) {
91699       {
91700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91701       };
91702     } catch (...) {
91703       {
91704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91705       };
91706     }
91707   }
91708
91709   jresult = result;
91710   return jresult;
91711 }
91712
91713
91714 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
91715   unsigned int jresult ;
91716   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91717   int arg2 ;
91718   unsigned int *result = 0 ;
91719
91720   arg1 = (std::vector< unsigned int > *)jarg1;
91721   arg2 = (int)jarg2;
91722   {
91723     try {
91724       try {
91725         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
91726       }
91727       catch(std::out_of_range &_e) {
91728         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91729         return 0;
91730       }
91731
91732     } catch (std::out_of_range& e) {
91733       {
91734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91735       };
91736     } catch (std::exception& e) {
91737       {
91738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91739       };
91740     } catch (Dali::DaliException e) {
91741       {
91742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91743       };
91744     } catch (...) {
91745       {
91746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91747       };
91748     }
91749   }
91750
91751   jresult = *result;
91752   return jresult;
91753 }
91754
91755
91756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
91757   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91758   int arg2 ;
91759   unsigned int *arg3 = 0 ;
91760   unsigned int temp3 ;
91761
91762   arg1 = (std::vector< unsigned int > *)jarg1;
91763   arg2 = (int)jarg2;
91764   temp3 = (unsigned int)jarg3;
91765   arg3 = &temp3;
91766   {
91767     try {
91768       try {
91769         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
91770       }
91771       catch(std::out_of_range &_e) {
91772         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91773         return ;
91774       }
91775
91776     } catch (std::out_of_range& e) {
91777       {
91778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91779       };
91780     } catch (std::exception& e) {
91781       {
91782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91783       };
91784     } catch (Dali::DaliException e) {
91785       {
91786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91787       };
91788     } catch (...) {
91789       {
91790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91791       };
91792     }
91793   }
91794
91795 }
91796
91797
91798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
91799   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91800   std::vector< unsigned int > *arg2 = 0 ;
91801
91802   arg1 = (std::vector< unsigned int > *)jarg1;
91803   arg2 = (std::vector< unsigned int > *)jarg2;
91804   if (!arg2) {
91805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91806     return ;
91807   }
91808   {
91809     try {
91810       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
91811     } catch (std::out_of_range& e) {
91812       {
91813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91814       };
91815     } catch (std::exception& e) {
91816       {
91817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91818       };
91819     } catch (Dali::DaliException e) {
91820       {
91821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91822       };
91823     } catch (...) {
91824       {
91825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91826       };
91827     }
91828   }
91829
91830 }
91831
91832
91833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
91834   void * jresult ;
91835   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91836   int arg2 ;
91837   int arg3 ;
91838   std::vector< unsigned int > *result = 0 ;
91839
91840   arg1 = (std::vector< unsigned int > *)jarg1;
91841   arg2 = (int)jarg2;
91842   arg3 = (int)jarg3;
91843   {
91844     try {
91845       try {
91846         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
91847       }
91848       catch(std::out_of_range &_e) {
91849         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91850         return 0;
91851       }
91852       catch(std::invalid_argument &_e) {
91853         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91854         return 0;
91855       }
91856
91857     } catch (std::out_of_range& e) {
91858       {
91859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91860       };
91861     } catch (std::exception& e) {
91862       {
91863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91864       };
91865     } catch (Dali::DaliException e) {
91866       {
91867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91868       };
91869     } catch (...) {
91870       {
91871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91872       };
91873     }
91874   }
91875
91876   jresult = (void *)result;
91877   return jresult;
91878 }
91879
91880
91881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
91882   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91883   int arg2 ;
91884   unsigned int *arg3 = 0 ;
91885   unsigned int temp3 ;
91886
91887   arg1 = (std::vector< unsigned int > *)jarg1;
91888   arg2 = (int)jarg2;
91889   temp3 = (unsigned int)jarg3;
91890   arg3 = &temp3;
91891   {
91892     try {
91893       try {
91894         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
91895       }
91896       catch(std::out_of_range &_e) {
91897         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91898         return ;
91899       }
91900
91901     } catch (std::out_of_range& e) {
91902       {
91903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91904       };
91905     } catch (std::exception& e) {
91906       {
91907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91908       };
91909     } catch (Dali::DaliException e) {
91910       {
91911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91912       };
91913     } catch (...) {
91914       {
91915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91916       };
91917     }
91918   }
91919
91920 }
91921
91922
91923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
91924   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91925   int arg2 ;
91926   std::vector< unsigned int > *arg3 = 0 ;
91927
91928   arg1 = (std::vector< unsigned int > *)jarg1;
91929   arg2 = (int)jarg2;
91930   arg3 = (std::vector< unsigned int > *)jarg3;
91931   if (!arg3) {
91932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91933     return ;
91934   }
91935   {
91936     try {
91937       try {
91938         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
91939       }
91940       catch(std::out_of_range &_e) {
91941         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91942         return ;
91943       }
91944
91945     } catch (std::out_of_range& e) {
91946       {
91947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91948       };
91949     } catch (std::exception& e) {
91950       {
91951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91952       };
91953     } catch (Dali::DaliException e) {
91954       {
91955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91956       };
91957     } catch (...) {
91958       {
91959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91960       };
91961     }
91962   }
91963
91964 }
91965
91966
91967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
91968   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91969   int arg2 ;
91970
91971   arg1 = (std::vector< unsigned int > *)jarg1;
91972   arg2 = (int)jarg2;
91973   {
91974     try {
91975       try {
91976         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
91977       }
91978       catch(std::out_of_range &_e) {
91979         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91980         return ;
91981       }
91982
91983     } catch (std::out_of_range& e) {
91984       {
91985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91986       };
91987     } catch (std::exception& e) {
91988       {
91989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91990       };
91991     } catch (Dali::DaliException e) {
91992       {
91993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91994       };
91995     } catch (...) {
91996       {
91997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91998       };
91999     }
92000   }
92001
92002 }
92003
92004
92005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
92006   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92007   int arg2 ;
92008   int arg3 ;
92009
92010   arg1 = (std::vector< unsigned int > *)jarg1;
92011   arg2 = (int)jarg2;
92012   arg3 = (int)jarg3;
92013   {
92014     try {
92015       try {
92016         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
92017       }
92018       catch(std::out_of_range &_e) {
92019         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92020         return ;
92021       }
92022       catch(std::invalid_argument &_e) {
92023         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92024         return ;
92025       }
92026
92027     } catch (std::out_of_range& e) {
92028       {
92029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92030       };
92031     } catch (std::exception& e) {
92032       {
92033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92034       };
92035     } catch (Dali::DaliException e) {
92036       {
92037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92038       };
92039     } catch (...) {
92040       {
92041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92042       };
92043     }
92044   }
92045
92046 }
92047
92048
92049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
92050   void * jresult ;
92051   unsigned int *arg1 = 0 ;
92052   int arg2 ;
92053   unsigned int temp1 ;
92054   std::vector< unsigned int > *result = 0 ;
92055
92056   temp1 = (unsigned int)jarg1;
92057   arg1 = &temp1;
92058   arg2 = (int)jarg2;
92059   {
92060     try {
92061       try {
92062         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
92063       }
92064       catch(std::out_of_range &_e) {
92065         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92066         return 0;
92067       }
92068
92069     } catch (std::out_of_range& e) {
92070       {
92071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92072       };
92073     } catch (std::exception& e) {
92074       {
92075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92076       };
92077     } catch (Dali::DaliException e) {
92078       {
92079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92080       };
92081     } catch (...) {
92082       {
92083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92084       };
92085     }
92086   }
92087
92088   jresult = (void *)result;
92089   return jresult;
92090 }
92091
92092
92093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
92094   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92095
92096   arg1 = (std::vector< unsigned int > *)jarg1;
92097   {
92098     try {
92099       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
92100     } catch (std::out_of_range& e) {
92101       {
92102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92103       };
92104     } catch (std::exception& e) {
92105       {
92106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92107       };
92108     } catch (Dali::DaliException e) {
92109       {
92110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92111       };
92112     } catch (...) {
92113       {
92114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92115       };
92116     }
92117   }
92118
92119 }
92120
92121
92122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
92123   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92124   int arg2 ;
92125   int arg3 ;
92126
92127   arg1 = (std::vector< unsigned int > *)jarg1;
92128   arg2 = (int)jarg2;
92129   arg3 = (int)jarg3;
92130   {
92131     try {
92132       try {
92133         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
92134       }
92135       catch(std::out_of_range &_e) {
92136         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92137         return ;
92138       }
92139       catch(std::invalid_argument &_e) {
92140         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92141         return ;
92142       }
92143
92144     } catch (std::out_of_range& e) {
92145       {
92146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92147       };
92148     } catch (std::exception& e) {
92149       {
92150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92151       };
92152     } catch (Dali::DaliException e) {
92153       {
92154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92155       };
92156     } catch (...) {
92157       {
92158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92159       };
92160     }
92161   }
92162
92163 }
92164
92165
92166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
92167   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92168   int arg2 ;
92169   std::vector< unsigned int > *arg3 = 0 ;
92170
92171   arg1 = (std::vector< unsigned int > *)jarg1;
92172   arg2 = (int)jarg2;
92173   arg3 = (std::vector< unsigned int > *)jarg3;
92174   if (!arg3) {
92175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92176     return ;
92177   }
92178   {
92179     try {
92180       try {
92181         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
92182       }
92183       catch(std::out_of_range &_e) {
92184         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92185         return ;
92186       }
92187
92188     } catch (std::out_of_range& e) {
92189       {
92190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92191       };
92192     } catch (std::exception& e) {
92193       {
92194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92195       };
92196     } catch (Dali::DaliException e) {
92197       {
92198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92199       };
92200     } catch (...) {
92201       {
92202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92203       };
92204     }
92205   }
92206
92207 }
92208
92209
92210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
92211   unsigned int jresult ;
92212   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92213   unsigned int *arg2 = 0 ;
92214   unsigned int temp2 ;
92215   bool result;
92216
92217   arg1 = (std::vector< unsigned int > *)jarg1;
92218   temp2 = (unsigned int)jarg2;
92219   arg2 = &temp2;
92220   {
92221     try {
92222       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
92223     } catch (std::out_of_range& e) {
92224       {
92225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92226       };
92227     } catch (std::exception& e) {
92228       {
92229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92230       };
92231     } catch (Dali::DaliException e) {
92232       {
92233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92234       };
92235     } catch (...) {
92236       {
92237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92238       };
92239     }
92240   }
92241
92242   jresult = result;
92243   return jresult;
92244 }
92245
92246
92247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
92248   int jresult ;
92249   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92250   unsigned int *arg2 = 0 ;
92251   unsigned int temp2 ;
92252   int result;
92253
92254   arg1 = (std::vector< unsigned int > *)jarg1;
92255   temp2 = (unsigned int)jarg2;
92256   arg2 = &temp2;
92257   {
92258     try {
92259       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
92260     } catch (std::out_of_range& e) {
92261       {
92262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92263       };
92264     } catch (std::exception& e) {
92265       {
92266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92267       };
92268     } catch (Dali::DaliException e) {
92269       {
92270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92271       };
92272     } catch (...) {
92273       {
92274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92275       };
92276     }
92277   }
92278
92279   jresult = result;
92280   return jresult;
92281 }
92282
92283
92284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
92285   int jresult ;
92286   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92287   unsigned int *arg2 = 0 ;
92288   unsigned int temp2 ;
92289   int result;
92290
92291   arg1 = (std::vector< unsigned int > *)jarg1;
92292   temp2 = (unsigned int)jarg2;
92293   arg2 = &temp2;
92294   {
92295     try {
92296       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
92297     } catch (std::out_of_range& e) {
92298       {
92299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92300       };
92301     } catch (std::exception& e) {
92302       {
92303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92304       };
92305     } catch (Dali::DaliException e) {
92306       {
92307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92308       };
92309     } catch (...) {
92310       {
92311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92312       };
92313     }
92314   }
92315
92316   jresult = result;
92317   return jresult;
92318 }
92319
92320
92321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
92322   unsigned int jresult ;
92323   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92324   unsigned int *arg2 = 0 ;
92325   unsigned int temp2 ;
92326   bool result;
92327
92328   arg1 = (std::vector< unsigned int > *)jarg1;
92329   temp2 = (unsigned int)jarg2;
92330   arg2 = &temp2;
92331   {
92332     try {
92333       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
92334     } catch (std::out_of_range& e) {
92335       {
92336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92337       };
92338     } catch (std::exception& e) {
92339       {
92340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92341       };
92342     } catch (Dali::DaliException e) {
92343       {
92344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92345       };
92346     } catch (...) {
92347       {
92348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92349       };
92350     }
92351   }
92352
92353   jresult = result;
92354   return jresult;
92355 }
92356
92357
92358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
92359   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92360
92361   arg1 = (std::vector< unsigned int > *)jarg1;
92362   {
92363     try {
92364       delete arg1;
92365     } catch (std::out_of_range& e) {
92366       {
92367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92368       };
92369     } catch (std::exception& e) {
92370       {
92371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92372       };
92373     } catch (Dali::DaliException e) {
92374       {
92375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92376       };
92377     } catch (...) {
92378       {
92379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92380       };
92381     }
92382   }
92383
92384 }
92385
92386
92387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
92388   void * jresult ;
92389   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92390
92391   {
92392     try {
92393       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
92394     } catch (std::out_of_range& e) {
92395       {
92396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92397       };
92398     } catch (std::exception& e) {
92399       {
92400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92401       };
92402     } catch (Dali::DaliException e) {
92403       {
92404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92405       };
92406     } catch (...) {
92407       {
92408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92409       };
92410     }
92411   }
92412
92413   jresult = (void *)result;
92414   return jresult;
92415 }
92416
92417
92418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
92419   void * jresult ;
92420   unsigned int arg1 ;
92421   Dali::Actor arg2 ;
92422   Dali::Actor *argp2 ;
92423   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92424
92425   arg1 = (unsigned int)jarg1;
92426   argp2 = (Dali::Actor *)jarg2;
92427   if (!argp2) {
92428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92429     return 0;
92430   }
92431   arg2 = *argp2;
92432   {
92433     try {
92434       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
92435     } catch (std::out_of_range& e) {
92436       {
92437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92438       };
92439     } catch (std::exception& e) {
92440       {
92441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92442       };
92443     } catch (Dali::DaliException e) {
92444       {
92445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92446       };
92447     } catch (...) {
92448       {
92449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92450       };
92451     }
92452   }
92453
92454   jresult = (void *)result;
92455   return jresult;
92456 }
92457
92458
92459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
92460   void * jresult ;
92461   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
92462   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92463
92464   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92465   if (!arg1) {
92466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92467     return 0;
92468   }
92469   {
92470     try {
92471       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
92472     } catch (std::out_of_range& e) {
92473       {
92474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92475       };
92476     } catch (std::exception& e) {
92477       {
92478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92479       };
92480     } catch (Dali::DaliException e) {
92481       {
92482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92483       };
92484     } catch (...) {
92485       {
92486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92487       };
92488     }
92489   }
92490
92491   jresult = (void *)result;
92492   return jresult;
92493 }
92494
92495
92496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
92497   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92498   unsigned int arg2 ;
92499
92500   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92501   arg2 = (unsigned int)jarg2;
92502   if (arg1) (arg1)->first = arg2;
92503 }
92504
92505
92506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
92507   unsigned int jresult ;
92508   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92509   unsigned int result;
92510
92511   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92512   result = (unsigned int) ((arg1)->first);
92513   jresult = result;
92514   return jresult;
92515 }
92516
92517
92518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
92519   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92520   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
92521
92522   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92523   arg2 = (Dali::Actor *)jarg2;
92524   if (arg1) (arg1)->second = *arg2;
92525 }
92526
92527
92528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
92529   void * jresult ;
92530   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92531   Dali::Actor *result = 0 ;
92532
92533   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92534   result = (Dali::Actor *)& ((arg1)->second);
92535   jresult = (void *)result;
92536   return jresult;
92537 }
92538
92539
92540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
92541   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92542
92543   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92544   {
92545     try {
92546       delete arg1;
92547     } catch (std::out_of_range& e) {
92548       {
92549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92550       };
92551     } catch (std::exception& e) {
92552       {
92553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92554       };
92555     } catch (Dali::DaliException e) {
92556       {
92557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92558       };
92559     } catch (...) {
92560       {
92561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92562       };
92563     }
92564   }
92565
92566 }
92567
92568
92569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
92570   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92571
92572   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92573   {
92574     try {
92575       (arg1)->clear();
92576     } catch (std::out_of_range& e) {
92577       {
92578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92579       };
92580     } catch (std::exception& e) {
92581       {
92582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92583       };
92584     } catch (Dali::DaliException e) {
92585       {
92586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92587       };
92588     } catch (...) {
92589       {
92590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92591       };
92592     }
92593   }
92594
92595 }
92596
92597
92598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
92599   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92600   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
92601
92602   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92603   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
92604   if (!arg2) {
92605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92606     return ;
92607   }
92608   {
92609     try {
92610       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
92611     } catch (std::out_of_range& e) {
92612       {
92613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92614       };
92615     } catch (std::exception& e) {
92616       {
92617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92618       };
92619     } catch (Dali::DaliException e) {
92620       {
92621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92622       };
92623     } catch (...) {
92624       {
92625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92626       };
92627     }
92628   }
92629
92630 }
92631
92632
92633 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
92634   unsigned long jresult ;
92635   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92636   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
92637
92638   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92639   {
92640     try {
92641       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
92642     } catch (std::out_of_range& e) {
92643       {
92644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92645       };
92646     } catch (std::exception& e) {
92647       {
92648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92649       };
92650     } catch (Dali::DaliException e) {
92651       {
92652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92653       };
92654     } catch (...) {
92655       {
92656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92657       };
92658     }
92659   }
92660
92661   jresult = (unsigned long)result;
92662   return jresult;
92663 }
92664
92665
92666 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
92667   unsigned long jresult ;
92668   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92669   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
92670
92671   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92672   {
92673     try {
92674       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
92675     } catch (std::out_of_range& e) {
92676       {
92677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92678       };
92679     } catch (std::exception& e) {
92680       {
92681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92682       };
92683     } catch (Dali::DaliException e) {
92684       {
92685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92686       };
92687     } catch (...) {
92688       {
92689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92690       };
92691     }
92692   }
92693
92694   jresult = (unsigned long)result;
92695   return jresult;
92696 }
92697
92698
92699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
92700   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92701   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
92702
92703   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92704   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
92705   {
92706     try {
92707       (arg1)->reserve(arg2);
92708     } catch (std::out_of_range& e) {
92709       {
92710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92711       };
92712     } catch (std::exception& e) {
92713       {
92714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92715       };
92716     } catch (Dali::DaliException e) {
92717       {
92718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92719       };
92720     } catch (...) {
92721       {
92722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92723       };
92724     }
92725   }
92726
92727 }
92728
92729
92730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
92731   void * jresult ;
92732   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92733
92734   {
92735     try {
92736       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
92737     } catch (std::out_of_range& e) {
92738       {
92739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92740       };
92741     } catch (std::exception& e) {
92742       {
92743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92744       };
92745     } catch (Dali::DaliException e) {
92746       {
92747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92748       };
92749     } catch (...) {
92750       {
92751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92752       };
92753     }
92754   }
92755
92756   jresult = (void *)result;
92757   return jresult;
92758 }
92759
92760
92761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
92762   void * jresult ;
92763   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
92764   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92765
92766   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92767   if (!arg1) {
92768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
92769     return 0;
92770   }
92771   {
92772     try {
92773       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);
92774     } catch (std::out_of_range& e) {
92775       {
92776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92777       };
92778     } catch (std::exception& e) {
92779       {
92780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92781       };
92782     } catch (Dali::DaliException e) {
92783       {
92784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92785       };
92786     } catch (...) {
92787       {
92788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92789       };
92790     }
92791   }
92792
92793   jresult = (void *)result;
92794   return jresult;
92795 }
92796
92797
92798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
92799   void * jresult ;
92800   int arg1 ;
92801   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92802
92803   arg1 = (int)jarg1;
92804   {
92805     try {
92806       try {
92807         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);
92808       }
92809       catch(std::out_of_range &_e) {
92810         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92811         return 0;
92812       }
92813
92814     } catch (std::out_of_range& e) {
92815       {
92816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92817       };
92818     } catch (std::exception& e) {
92819       {
92820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92821       };
92822     } catch (Dali::DaliException e) {
92823       {
92824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92825       };
92826     } catch (...) {
92827       {
92828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92829       };
92830     }
92831   }
92832
92833   jresult = (void *)result;
92834   return jresult;
92835 }
92836
92837
92838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
92839   void * jresult ;
92840   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92841   int arg2 ;
92842   std::pair< unsigned int,Dali::Actor > result;
92843
92844   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92845   arg2 = (int)jarg2;
92846   {
92847     try {
92848       try {
92849         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
92850       }
92851       catch(std::out_of_range &_e) {
92852         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92853         return 0;
92854       }
92855
92856     } catch (std::out_of_range& e) {
92857       {
92858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92859       };
92860     } catch (std::exception& e) {
92861       {
92862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92863       };
92864     } catch (Dali::DaliException e) {
92865       {
92866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92867       };
92868     } catch (...) {
92869       {
92870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92871       };
92872     }
92873   }
92874
92875   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
92876   return jresult;
92877 }
92878
92879
92880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
92881   void * jresult ;
92882   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92883   int arg2 ;
92884   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92885
92886   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92887   arg2 = (int)jarg2;
92888   {
92889     try {
92890       try {
92891         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
92892       }
92893       catch(std::out_of_range &_e) {
92894         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92895         return 0;
92896       }
92897
92898     } catch (std::out_of_range& e) {
92899       {
92900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92901       };
92902     } catch (std::exception& e) {
92903       {
92904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92905       };
92906     } catch (Dali::DaliException e) {
92907       {
92908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92909       };
92910     } catch (...) {
92911       {
92912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92913       };
92914     }
92915   }
92916
92917   jresult = (void *)result;
92918   return jresult;
92919 }
92920
92921
92922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
92923   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92924   int arg2 ;
92925   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
92926
92927   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92928   arg2 = (int)jarg2;
92929   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
92930   if (!arg3) {
92931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92932     return ;
92933   }
92934   {
92935     try {
92936       try {
92937         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);
92938       }
92939       catch(std::out_of_range &_e) {
92940         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92941         return ;
92942       }
92943
92944     } catch (std::out_of_range& e) {
92945       {
92946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92947       };
92948     } catch (std::exception& e) {
92949       {
92950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92951       };
92952     } catch (Dali::DaliException e) {
92953       {
92954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92955       };
92956     } catch (...) {
92957       {
92958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92959       };
92960     }
92961   }
92962
92963 }
92964
92965
92966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
92967   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92968   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
92969
92970   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92971   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
92972   if (!arg2) {
92973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
92974     return ;
92975   }
92976   {
92977     try {
92978       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);
92979     } catch (std::out_of_range& e) {
92980       {
92981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92982       };
92983     } catch (std::exception& e) {
92984       {
92985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92986       };
92987     } catch (Dali::DaliException e) {
92988       {
92989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92990       };
92991     } catch (...) {
92992       {
92993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92994       };
92995     }
92996   }
92997
92998 }
92999
93000
93001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93002   void * jresult ;
93003   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93004   int arg2 ;
93005   int arg3 ;
93006   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93007
93008   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93009   arg2 = (int)jarg2;
93010   arg3 = (int)jarg3;
93011   {
93012     try {
93013       try {
93014         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);
93015       }
93016       catch(std::out_of_range &_e) {
93017         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93018         return 0;
93019       }
93020       catch(std::invalid_argument &_e) {
93021         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93022         return 0;
93023       }
93024
93025     } catch (std::out_of_range& e) {
93026       {
93027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93028       };
93029     } catch (std::exception& e) {
93030       {
93031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93032       };
93033     } catch (Dali::DaliException e) {
93034       {
93035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93036       };
93037     } catch (...) {
93038       {
93039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93040       };
93041     }
93042   }
93043
93044   jresult = (void *)result;
93045   return jresult;
93046 }
93047
93048
93049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
93050   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93051   int arg2 ;
93052   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
93053
93054   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93055   arg2 = (int)jarg2;
93056   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
93057   if (!arg3) {
93058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93059     return ;
93060   }
93061   {
93062     try {
93063       try {
93064         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);
93065       }
93066       catch(std::out_of_range &_e) {
93067         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93068         return ;
93069       }
93070
93071     } catch (std::out_of_range& e) {
93072       {
93073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93074       };
93075     } catch (std::exception& e) {
93076       {
93077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93078       };
93079     } catch (Dali::DaliException e) {
93080       {
93081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93082       };
93083     } catch (...) {
93084       {
93085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93086       };
93087     }
93088   }
93089
93090 }
93091
93092
93093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93094   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93095   int arg2 ;
93096   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
93097
93098   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93099   arg2 = (int)jarg2;
93100   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
93101   if (!arg3) {
93102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93103     return ;
93104   }
93105   {
93106     try {
93107       try {
93108         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);
93109       }
93110       catch(std::out_of_range &_e) {
93111         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93112         return ;
93113       }
93114
93115     } catch (std::out_of_range& e) {
93116       {
93117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93118       };
93119     } catch (std::exception& e) {
93120       {
93121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93122       };
93123     } catch (Dali::DaliException e) {
93124       {
93125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93126       };
93127     } catch (...) {
93128       {
93129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93130       };
93131     }
93132   }
93133
93134 }
93135
93136
93137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
93138   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93139   int arg2 ;
93140
93141   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93142   arg2 = (int)jarg2;
93143   {
93144     try {
93145       try {
93146         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
93147       }
93148       catch(std::out_of_range &_e) {
93149         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93150         return ;
93151       }
93152
93153     } catch (std::out_of_range& e) {
93154       {
93155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93156       };
93157     } catch (std::exception& e) {
93158       {
93159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93160       };
93161     } catch (Dali::DaliException e) {
93162       {
93163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93164       };
93165     } catch (...) {
93166       {
93167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93168       };
93169     }
93170   }
93171
93172 }
93173
93174
93175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93176   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93177   int arg2 ;
93178   int arg3 ;
93179
93180   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93181   arg2 = (int)jarg2;
93182   arg3 = (int)jarg3;
93183   {
93184     try {
93185       try {
93186         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
93187       }
93188       catch(std::out_of_range &_e) {
93189         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93190         return ;
93191       }
93192       catch(std::invalid_argument &_e) {
93193         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93194         return ;
93195       }
93196
93197     } catch (std::out_of_range& e) {
93198       {
93199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93200       };
93201     } catch (std::exception& e) {
93202       {
93203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93204       };
93205     } catch (Dali::DaliException e) {
93206       {
93207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93208       };
93209     } catch (...) {
93210       {
93211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93212       };
93213     }
93214   }
93215
93216 }
93217
93218
93219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
93220   void * jresult ;
93221   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93222   int arg2 ;
93223   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93224
93225   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93226   if (!arg1) {
93227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93228     return 0;
93229   }
93230   arg2 = (int)jarg2;
93231   {
93232     try {
93233       try {
93234         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);
93235       }
93236       catch(std::out_of_range &_e) {
93237         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93238         return 0;
93239       }
93240
93241     } catch (std::out_of_range& e) {
93242       {
93243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93244       };
93245     } catch (std::exception& e) {
93246       {
93247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93248       };
93249     } catch (Dali::DaliException e) {
93250       {
93251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93252       };
93253     } catch (...) {
93254       {
93255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93256       };
93257     }
93258   }
93259
93260   jresult = (void *)result;
93261   return jresult;
93262 }
93263
93264
93265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
93266   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93267
93268   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93269   {
93270     try {
93271       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
93272     } catch (std::out_of_range& e) {
93273       {
93274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93275       };
93276     } catch (std::exception& e) {
93277       {
93278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93279       };
93280     } catch (Dali::DaliException e) {
93281       {
93282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93283       };
93284     } catch (...) {
93285       {
93286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93287       };
93288     }
93289   }
93290
93291 }
93292
93293
93294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93295   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93296   int arg2 ;
93297   int arg3 ;
93298
93299   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93300   arg2 = (int)jarg2;
93301   arg3 = (int)jarg3;
93302   {
93303     try {
93304       try {
93305         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93306       }
93307       catch(std::out_of_range &_e) {
93308         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93309         return ;
93310       }
93311       catch(std::invalid_argument &_e) {
93312         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93313         return ;
93314       }
93315
93316     } catch (std::out_of_range& e) {
93317       {
93318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93319       };
93320     } catch (std::exception& e) {
93321       {
93322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93323       };
93324     } catch (Dali::DaliException e) {
93325       {
93326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93327       };
93328     } catch (...) {
93329       {
93330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93331       };
93332     }
93333   }
93334
93335 }
93336
93337
93338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93339   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93340   int arg2 ;
93341   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
93342
93343   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93344   arg2 = (int)jarg2;
93345   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
93346   if (!arg3) {
93347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93348     return ;
93349   }
93350   {
93351     try {
93352       try {
93353         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);
93354       }
93355       catch(std::out_of_range &_e) {
93356         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93357         return ;
93358       }
93359
93360     } catch (std::out_of_range& e) {
93361       {
93362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93363       };
93364     } catch (std::exception& e) {
93365       {
93366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93367       };
93368     } catch (Dali::DaliException e) {
93369       {
93370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93371       };
93372     } catch (...) {
93373       {
93374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93375       };
93376     }
93377   }
93378
93379 }
93380
93381
93382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
93383   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93384
93385   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93386   {
93387     try {
93388       delete arg1;
93389     } catch (std::out_of_range& e) {
93390       {
93391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93392       };
93393     } catch (std::exception& e) {
93394       {
93395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93396       };
93397     } catch (Dali::DaliException e) {
93398       {
93399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93400       };
93401     } catch (...) {
93402       {
93403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93404       };
93405     }
93406   }
93407
93408 }
93409
93410
93411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
93412   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93413
93414   arg1 = (std::vector< Dali::Actor > *)jarg1;
93415   {
93416     try {
93417       (arg1)->clear();
93418     } catch (std::out_of_range& e) {
93419       {
93420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93421       };
93422     } catch (std::exception& e) {
93423       {
93424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93425       };
93426     } catch (Dali::DaliException e) {
93427       {
93428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93429       };
93430     } catch (...) {
93431       {
93432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93433       };
93434     }
93435   }
93436
93437 }
93438
93439
93440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
93441   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93442   Dali::Actor *arg2 = 0 ;
93443
93444   arg1 = (std::vector< Dali::Actor > *)jarg1;
93445   arg2 = (Dali::Actor *)jarg2;
93446   if (!arg2) {
93447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93448     return ;
93449   }
93450   {
93451     try {
93452       (arg1)->push_back((Dali::Actor const &)*arg2);
93453     } catch (std::out_of_range& e) {
93454       {
93455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93456       };
93457     } catch (std::exception& e) {
93458       {
93459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93460       };
93461     } catch (Dali::DaliException e) {
93462       {
93463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93464       };
93465     } catch (...) {
93466       {
93467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93468       };
93469     }
93470   }
93471
93472 }
93473
93474
93475 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
93476   unsigned long jresult ;
93477   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93478   std::vector< Dali::Actor >::size_type result;
93479
93480   arg1 = (std::vector< Dali::Actor > *)jarg1;
93481   {
93482     try {
93483       result = ((std::vector< Dali::Actor > const *)arg1)->size();
93484     } catch (std::out_of_range& e) {
93485       {
93486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93487       };
93488     } catch (std::exception& e) {
93489       {
93490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93491       };
93492     } catch (Dali::DaliException e) {
93493       {
93494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93495       };
93496     } catch (...) {
93497       {
93498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93499       };
93500     }
93501   }
93502
93503   jresult = (unsigned long)result;
93504   return jresult;
93505 }
93506
93507
93508 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
93509   unsigned long jresult ;
93510   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93511   std::vector< Dali::Actor >::size_type result;
93512
93513   arg1 = (std::vector< Dali::Actor > *)jarg1;
93514   {
93515     try {
93516       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
93517     } catch (std::out_of_range& e) {
93518       {
93519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93520       };
93521     } catch (std::exception& e) {
93522       {
93523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93524       };
93525     } catch (Dali::DaliException e) {
93526       {
93527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93528       };
93529     } catch (...) {
93530       {
93531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93532       };
93533     }
93534   }
93535
93536   jresult = (unsigned long)result;
93537   return jresult;
93538 }
93539
93540
93541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
93542   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93543   std::vector< Dali::Actor >::size_type arg2 ;
93544
93545   arg1 = (std::vector< Dali::Actor > *)jarg1;
93546   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
93547   {
93548     try {
93549       (arg1)->reserve(arg2);
93550     } catch (std::out_of_range& e) {
93551       {
93552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93553       };
93554     } catch (std::exception& e) {
93555       {
93556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93557       };
93558     } catch (Dali::DaliException e) {
93559       {
93560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93561       };
93562     } catch (...) {
93563       {
93564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93565       };
93566     }
93567   }
93568
93569 }
93570
93571
93572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
93573   void * jresult ;
93574   std::vector< Dali::Actor > *result = 0 ;
93575
93576   {
93577     try {
93578       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
93579     } catch (std::out_of_range& e) {
93580       {
93581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93582       };
93583     } catch (std::exception& e) {
93584       {
93585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93586       };
93587     } catch (Dali::DaliException e) {
93588       {
93589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93590       };
93591     } catch (...) {
93592       {
93593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93594       };
93595     }
93596   }
93597
93598   jresult = (void *)result;
93599   return jresult;
93600 }
93601
93602
93603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
93604   void * jresult ;
93605   std::vector< Dali::Actor > *arg1 = 0 ;
93606   std::vector< Dali::Actor > *result = 0 ;
93607
93608   arg1 = (std::vector< Dali::Actor > *)jarg1;
93609   if (!arg1) {
93610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93611     return 0;
93612   }
93613   {
93614     try {
93615       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
93616     } catch (std::out_of_range& e) {
93617       {
93618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93619       };
93620     } catch (std::exception& e) {
93621       {
93622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93623       };
93624     } catch (Dali::DaliException e) {
93625       {
93626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93627       };
93628     } catch (...) {
93629       {
93630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93631       };
93632     }
93633   }
93634
93635   jresult = (void *)result;
93636   return jresult;
93637 }
93638
93639
93640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
93641   void * jresult ;
93642   int arg1 ;
93643   std::vector< Dali::Actor > *result = 0 ;
93644
93645   arg1 = (int)jarg1;
93646   {
93647     try {
93648       try {
93649         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
93650       }
93651       catch(std::out_of_range &_e) {
93652         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93653         return 0;
93654       }
93655
93656     } catch (std::out_of_range& e) {
93657       {
93658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93659       };
93660     } catch (std::exception& e) {
93661       {
93662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93663       };
93664     } catch (Dali::DaliException e) {
93665       {
93666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93667       };
93668     } catch (...) {
93669       {
93670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93671       };
93672     }
93673   }
93674
93675   jresult = (void *)result;
93676   return jresult;
93677 }
93678
93679
93680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
93681   void * jresult ;
93682   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93683   int arg2 ;
93684   Dali::Actor result;
93685
93686   arg1 = (std::vector< Dali::Actor > *)jarg1;
93687   arg2 = (int)jarg2;
93688   {
93689     try {
93690       try {
93691         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
93692       }
93693       catch(std::out_of_range &_e) {
93694         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93695         return 0;
93696       }
93697
93698     } catch (std::out_of_range& e) {
93699       {
93700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93701       };
93702     } catch (std::exception& e) {
93703       {
93704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93705       };
93706     } catch (Dali::DaliException e) {
93707       {
93708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93709       };
93710     } catch (...) {
93711       {
93712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93713       };
93714     }
93715   }
93716
93717   jresult = new Dali::Actor((const Dali::Actor &)result);
93718   return jresult;
93719 }
93720
93721
93722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
93723   void * jresult ;
93724   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93725   int arg2 ;
93726   Dali::Actor *result = 0 ;
93727
93728   arg1 = (std::vector< Dali::Actor > *)jarg1;
93729   arg2 = (int)jarg2;
93730   {
93731     try {
93732       try {
93733         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
93734       }
93735       catch(std::out_of_range &_e) {
93736         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93737         return 0;
93738       }
93739
93740     } catch (std::out_of_range& e) {
93741       {
93742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93743       };
93744     } catch (std::exception& e) {
93745       {
93746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93747       };
93748     } catch (Dali::DaliException e) {
93749       {
93750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93751       };
93752     } catch (...) {
93753       {
93754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93755       };
93756     }
93757   }
93758
93759   jresult = (void *)result;
93760   return jresult;
93761 }
93762
93763
93764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
93765   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93766   int arg2 ;
93767   Dali::Actor *arg3 = 0 ;
93768
93769   arg1 = (std::vector< Dali::Actor > *)jarg1;
93770   arg2 = (int)jarg2;
93771   arg3 = (Dali::Actor *)jarg3;
93772   if (!arg3) {
93773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93774     return ;
93775   }
93776   {
93777     try {
93778       try {
93779         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
93780       }
93781       catch(std::out_of_range &_e) {
93782         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93783         return ;
93784       }
93785
93786     } catch (std::out_of_range& e) {
93787       {
93788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93789       };
93790     } catch (std::exception& e) {
93791       {
93792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93793       };
93794     } catch (Dali::DaliException e) {
93795       {
93796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93797       };
93798     } catch (...) {
93799       {
93800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93801       };
93802     }
93803   }
93804
93805 }
93806
93807
93808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
93809   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93810   std::vector< Dali::Actor > *arg2 = 0 ;
93811
93812   arg1 = (std::vector< Dali::Actor > *)jarg1;
93813   arg2 = (std::vector< Dali::Actor > *)jarg2;
93814   if (!arg2) {
93815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93816     return ;
93817   }
93818   {
93819     try {
93820       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
93821     } catch (std::out_of_range& e) {
93822       {
93823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93824       };
93825     } catch (std::exception& e) {
93826       {
93827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93828       };
93829     } catch (Dali::DaliException e) {
93830       {
93831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93832       };
93833     } catch (...) {
93834       {
93835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93836       };
93837     }
93838   }
93839
93840 }
93841
93842
93843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93844   void * jresult ;
93845   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93846   int arg2 ;
93847   int arg3 ;
93848   std::vector< Dali::Actor > *result = 0 ;
93849
93850   arg1 = (std::vector< Dali::Actor > *)jarg1;
93851   arg2 = (int)jarg2;
93852   arg3 = (int)jarg3;
93853   {
93854     try {
93855       try {
93856         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
93857       }
93858       catch(std::out_of_range &_e) {
93859         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93860         return 0;
93861       }
93862       catch(std::invalid_argument &_e) {
93863         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93864         return 0;
93865       }
93866
93867     } catch (std::out_of_range& e) {
93868       {
93869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93870       };
93871     } catch (std::exception& e) {
93872       {
93873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93874       };
93875     } catch (Dali::DaliException e) {
93876       {
93877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93878       };
93879     } catch (...) {
93880       {
93881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93882       };
93883     }
93884   }
93885
93886   jresult = (void *)result;
93887   return jresult;
93888 }
93889
93890
93891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
93892   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93893   int arg2 ;
93894   Dali::Actor *arg3 = 0 ;
93895
93896   arg1 = (std::vector< Dali::Actor > *)jarg1;
93897   arg2 = (int)jarg2;
93898   arg3 = (Dali::Actor *)jarg3;
93899   if (!arg3) {
93900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93901     return ;
93902   }
93903   {
93904     try {
93905       try {
93906         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
93907       }
93908       catch(std::out_of_range &_e) {
93909         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93910         return ;
93911       }
93912
93913     } catch (std::out_of_range& e) {
93914       {
93915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93916       };
93917     } catch (std::exception& e) {
93918       {
93919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93920       };
93921     } catch (Dali::DaliException e) {
93922       {
93923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93924       };
93925     } catch (...) {
93926       {
93927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93928       };
93929     }
93930   }
93931
93932 }
93933
93934
93935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93936   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93937   int arg2 ;
93938   std::vector< Dali::Actor > *arg3 = 0 ;
93939
93940   arg1 = (std::vector< Dali::Actor > *)jarg1;
93941   arg2 = (int)jarg2;
93942   arg3 = (std::vector< Dali::Actor > *)jarg3;
93943   if (!arg3) {
93944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93945     return ;
93946   }
93947   {
93948     try {
93949       try {
93950         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
93951       }
93952       catch(std::out_of_range &_e) {
93953         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93954         return ;
93955       }
93956
93957     } catch (std::out_of_range& e) {
93958       {
93959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93960       };
93961     } catch (std::exception& e) {
93962       {
93963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93964       };
93965     } catch (Dali::DaliException e) {
93966       {
93967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93968       };
93969     } catch (...) {
93970       {
93971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93972       };
93973     }
93974   }
93975
93976 }
93977
93978
93979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
93980   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93981   int arg2 ;
93982
93983   arg1 = (std::vector< Dali::Actor > *)jarg1;
93984   arg2 = (int)jarg2;
93985   {
93986     try {
93987       try {
93988         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
93989       }
93990       catch(std::out_of_range &_e) {
93991         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93992         return ;
93993       }
93994
93995     } catch (std::out_of_range& e) {
93996       {
93997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93998       };
93999     } catch (std::exception& e) {
94000       {
94001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94002       };
94003     } catch (Dali::DaliException e) {
94004       {
94005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94006       };
94007     } catch (...) {
94008       {
94009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94010       };
94011     }
94012   }
94013
94014 }
94015
94016
94017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94018   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94019   int arg2 ;
94020   int arg3 ;
94021
94022   arg1 = (std::vector< Dali::Actor > *)jarg1;
94023   arg2 = (int)jarg2;
94024   arg3 = (int)jarg3;
94025   {
94026     try {
94027       try {
94028         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
94029       }
94030       catch(std::out_of_range &_e) {
94031         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94032         return ;
94033       }
94034       catch(std::invalid_argument &_e) {
94035         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94036         return ;
94037       }
94038
94039     } catch (std::out_of_range& e) {
94040       {
94041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94042       };
94043     } catch (std::exception& e) {
94044       {
94045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94046       };
94047     } catch (Dali::DaliException e) {
94048       {
94049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94050       };
94051     } catch (...) {
94052       {
94053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94054       };
94055     }
94056   }
94057
94058 }
94059
94060
94061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
94062   void * jresult ;
94063   Dali::Actor *arg1 = 0 ;
94064   int arg2 ;
94065   std::vector< Dali::Actor > *result = 0 ;
94066
94067   arg1 = (Dali::Actor *)jarg1;
94068   if (!arg1) {
94069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94070     return 0;
94071   }
94072   arg2 = (int)jarg2;
94073   {
94074     try {
94075       try {
94076         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
94077       }
94078       catch(std::out_of_range &_e) {
94079         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94080         return 0;
94081       }
94082
94083     } catch (std::out_of_range& e) {
94084       {
94085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94086       };
94087     } catch (std::exception& e) {
94088       {
94089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94090       };
94091     } catch (Dali::DaliException e) {
94092       {
94093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94094       };
94095     } catch (...) {
94096       {
94097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94098       };
94099     }
94100   }
94101
94102   jresult = (void *)result;
94103   return jresult;
94104 }
94105
94106
94107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
94108   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94109
94110   arg1 = (std::vector< Dali::Actor > *)jarg1;
94111   {
94112     try {
94113       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
94114     } catch (std::out_of_range& e) {
94115       {
94116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94117       };
94118     } catch (std::exception& e) {
94119       {
94120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94121       };
94122     } catch (Dali::DaliException e) {
94123       {
94124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94125       };
94126     } catch (...) {
94127       {
94128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94129       };
94130     }
94131   }
94132
94133 }
94134
94135
94136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94137   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94138   int arg2 ;
94139   int arg3 ;
94140
94141   arg1 = (std::vector< Dali::Actor > *)jarg1;
94142   arg2 = (int)jarg2;
94143   arg3 = (int)jarg3;
94144   {
94145     try {
94146       try {
94147         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94148       }
94149       catch(std::out_of_range &_e) {
94150         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94151         return ;
94152       }
94153       catch(std::invalid_argument &_e) {
94154         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94155         return ;
94156       }
94157
94158     } catch (std::out_of_range& e) {
94159       {
94160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94161       };
94162     } catch (std::exception& e) {
94163       {
94164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94165       };
94166     } catch (Dali::DaliException e) {
94167       {
94168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94169       };
94170     } catch (...) {
94171       {
94172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94173       };
94174     }
94175   }
94176
94177 }
94178
94179
94180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94181   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94182   int arg2 ;
94183   std::vector< Dali::Actor > *arg3 = 0 ;
94184
94185   arg1 = (std::vector< Dali::Actor > *)jarg1;
94186   arg2 = (int)jarg2;
94187   arg3 = (std::vector< Dali::Actor > *)jarg3;
94188   if (!arg3) {
94189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94190     return ;
94191   }
94192   {
94193     try {
94194       try {
94195         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
94196       }
94197       catch(std::out_of_range &_e) {
94198         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94199         return ;
94200       }
94201
94202     } catch (std::out_of_range& e) {
94203       {
94204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94205       };
94206     } catch (std::exception& e) {
94207       {
94208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94209       };
94210     } catch (Dali::DaliException e) {
94211       {
94212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94213       };
94214     } catch (...) {
94215       {
94216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94217       };
94218     }
94219   }
94220
94221 }
94222
94223
94224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
94225   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94226
94227   arg1 = (std::vector< Dali::Actor > *)jarg1;
94228   {
94229     try {
94230       delete arg1;
94231     } catch (std::out_of_range& e) {
94232       {
94233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94234       };
94235     } catch (std::exception& e) {
94236       {
94237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94238       };
94239     } catch (Dali::DaliException e) {
94240       {
94241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94242       };
94243     } catch (...) {
94244       {
94245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94246       };
94247     }
94248   }
94249
94250 }
94251
94252
94253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
94254   unsigned int jresult ;
94255   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94256   bool result;
94257
94258   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94259   {
94260     try {
94261       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
94262     } catch (std::out_of_range& e) {
94263       {
94264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94265       };
94266     } catch (std::exception& e) {
94267       {
94268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94269       };
94270     } catch (Dali::DaliException e) {
94271       {
94272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94273       };
94274     } catch (...) {
94275       {
94276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94277       };
94278     }
94279   }
94280
94281   jresult = result;
94282   return jresult;
94283 }
94284
94285
94286 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
94287   unsigned long jresult ;
94288   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94289   std::size_t result;
94290
94291   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94292   {
94293     try {
94294       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
94295     } catch (std::out_of_range& e) {
94296       {
94297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94298       };
94299     } catch (std::exception& e) {
94300       {
94301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94302       };
94303     } catch (Dali::DaliException e) {
94304       {
94305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94306       };
94307     } catch (...) {
94308       {
94309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94310       };
94311     }
94312   }
94313
94314   jresult = (unsigned long)result;
94315   return jresult;
94316 }
94317
94318
94319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
94320   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94321   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
94322
94323   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94324   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
94325   {
94326     try {
94327       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
94328     } catch (std::out_of_range& e) {
94329       {
94330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94331       };
94332     } catch (std::exception& e) {
94333       {
94334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94335       };
94336     } catch (Dali::DaliException e) {
94337       {
94338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94339       };
94340     } catch (...) {
94341       {
94342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94343       };
94344     }
94345   }
94346
94347 }
94348
94349
94350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
94351   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94352   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
94353
94354   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94355   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
94356   {
94357     try {
94358       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
94359     } catch (std::out_of_range& e) {
94360       {
94361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94362       };
94363     } catch (std::exception& e) {
94364       {
94365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94366       };
94367     } catch (Dali::DaliException e) {
94368       {
94369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94370       };
94371     } catch (...) {
94372       {
94373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94374       };
94375     }
94376   }
94377
94378 }
94379
94380
94381 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
94382   unsigned int jresult ;
94383   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94384   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
94385   bool result;
94386
94387   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94388   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
94389   if (!arg2) {
94390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
94391     return 0;
94392   }
94393   {
94394     try {
94395       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
94396     } catch (std::out_of_range& e) {
94397       {
94398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94399       };
94400     } catch (std::exception& e) {
94401       {
94402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94403       };
94404     } catch (Dali::DaliException e) {
94405       {
94406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94407       };
94408     } catch (...) {
94409       {
94410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94411       };
94412     }
94413   }
94414
94415   jresult = result;
94416   return jresult;
94417 }
94418
94419
94420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
94421   void * jresult ;
94422   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
94423
94424   {
94425     try {
94426       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
94427     } catch (std::out_of_range& e) {
94428       {
94429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94430       };
94431     } catch (std::exception& e) {
94432       {
94433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94434       };
94435     } catch (Dali::DaliException e) {
94436       {
94437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94438       };
94439     } catch (...) {
94440       {
94441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94442       };
94443     }
94444   }
94445
94446   jresult = (void *)result;
94447   return jresult;
94448 }
94449
94450
94451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
94452   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94453
94454   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94455   {
94456     try {
94457       delete arg1;
94458     } catch (std::out_of_range& e) {
94459       {
94460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94461       };
94462     } catch (std::exception& e) {
94463       {
94464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94465       };
94466     } catch (Dali::DaliException e) {
94467       {
94468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94469       };
94470     } catch (...) {
94471       {
94472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94473       };
94474     }
94475   }
94476
94477 }
94478
94479
94480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
94481   unsigned int jresult ;
94482   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94483   bool result;
94484
94485   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94486   {
94487     try {
94488       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);
94489     } catch (std::out_of_range& e) {
94490       {
94491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94492       };
94493     } catch (std::exception& e) {
94494       {
94495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94496       };
94497     } catch (Dali::DaliException e) {
94498       {
94499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94500       };
94501     } catch (...) {
94502       {
94503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94504       };
94505     }
94506   }
94507
94508   jresult = result;
94509   return jresult;
94510 }
94511
94512
94513 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
94514   unsigned long jresult ;
94515   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94516   std::size_t result;
94517
94518   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94519   {
94520     try {
94521       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);
94522     } catch (std::out_of_range& e) {
94523       {
94524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94525       };
94526     } catch (std::exception& e) {
94527       {
94528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94529       };
94530     } catch (Dali::DaliException e) {
94531       {
94532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94533       };
94534     } catch (...) {
94535       {
94536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94537       };
94538     }
94539   }
94540
94541   jresult = (unsigned long)result;
94542   return jresult;
94543 }
94544
94545
94546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
94547   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94548   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
94549
94550   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94551   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
94552   {
94553     try {
94554       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
94555     } catch (std::out_of_range& e) {
94556       {
94557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94558       };
94559     } catch (std::exception& e) {
94560       {
94561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94562       };
94563     } catch (Dali::DaliException e) {
94564       {
94565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94566       };
94567     } catch (...) {
94568       {
94569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94570       };
94571     }
94572   }
94573
94574 }
94575
94576
94577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
94578   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94579   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
94580
94581   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94582   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
94583   {
94584     try {
94585       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
94586     } catch (std::out_of_range& e) {
94587       {
94588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94589       };
94590     } catch (std::exception& e) {
94591       {
94592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94593       };
94594     } catch (Dali::DaliException e) {
94595       {
94596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94597       };
94598     } catch (...) {
94599       {
94600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94601       };
94602     }
94603   }
94604
94605 }
94606
94607
94608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
94609   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94610   Dali::Actor arg2 ;
94611   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
94612   Dali::Actor *argp2 ;
94613
94614   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94615   argp2 = (Dali::Actor *)jarg2;
94616   if (!argp2) {
94617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94618     return ;
94619   }
94620   arg2 = *argp2;
94621   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
94622   {
94623     try {
94624       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
94625     } catch (std::out_of_range& e) {
94626       {
94627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94628       };
94629     } catch (std::exception& e) {
94630       {
94631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94632       };
94633     } catch (Dali::DaliException e) {
94634       {
94635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94636       };
94637     } catch (...) {
94638       {
94639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94640       };
94641     }
94642   }
94643
94644 }
94645
94646
94647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
94648   void * jresult ;
94649   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
94650
94651   {
94652     try {
94653       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
94654     } catch (std::out_of_range& e) {
94655       {
94656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94657       };
94658     } catch (std::exception& e) {
94659       {
94660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94661       };
94662     } catch (Dali::DaliException e) {
94663       {
94664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94665       };
94666     } catch (...) {
94667       {
94668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94669       };
94670     }
94671   }
94672
94673   jresult = (void *)result;
94674   return jresult;
94675 }
94676
94677
94678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
94679   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94680
94681   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94682   {
94683     try {
94684       delete arg1;
94685     } catch (std::out_of_range& e) {
94686       {
94687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94688       };
94689     } catch (std::exception& e) {
94690       {
94691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94692       };
94693     } catch (Dali::DaliException e) {
94694       {
94695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94696       };
94697     } catch (...) {
94698       {
94699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94700       };
94701     }
94702   }
94703
94704 }
94705
94706
94707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
94708   unsigned int jresult ;
94709   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94710   bool result;
94711
94712   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94713   {
94714     try {
94715       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
94716     } catch (std::out_of_range& e) {
94717       {
94718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94719       };
94720     } catch (std::exception& e) {
94721       {
94722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94723       };
94724     } catch (Dali::DaliException e) {
94725       {
94726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94727       };
94728     } catch (...) {
94729       {
94730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94731       };
94732     }
94733   }
94734
94735   jresult = result;
94736   return jresult;
94737 }
94738
94739
94740 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
94741   unsigned long jresult ;
94742   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94743   std::size_t result;
94744
94745   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94746   {
94747     try {
94748       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
94749     } catch (std::out_of_range& e) {
94750       {
94751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94752       };
94753     } catch (std::exception& e) {
94754       {
94755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94756       };
94757     } catch (Dali::DaliException e) {
94758       {
94759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94760       };
94761     } catch (...) {
94762       {
94763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94764       };
94765     }
94766   }
94767
94768   jresult = (unsigned long)result;
94769   return jresult;
94770 }
94771
94772
94773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
94774   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94775   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
94776
94777   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94778   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
94779   {
94780     try {
94781       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
94782     } catch (std::out_of_range& e) {
94783       {
94784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94785       };
94786     } catch (std::exception& e) {
94787       {
94788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94789       };
94790     } catch (Dali::DaliException e) {
94791       {
94792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94793       };
94794     } catch (...) {
94795       {
94796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94797       };
94798     }
94799   }
94800
94801 }
94802
94803
94804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
94805   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94806   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
94807
94808   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94809   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
94810   {
94811     try {
94812       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
94813     } catch (std::out_of_range& e) {
94814       {
94815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94816       };
94817     } catch (std::exception& e) {
94818       {
94819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94820       };
94821     } catch (Dali::DaliException e) {
94822       {
94823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94824       };
94825     } catch (...) {
94826       {
94827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94828       };
94829     }
94830   }
94831
94832 }
94833
94834
94835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
94836   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94837   Dali::Actor arg2 ;
94838   Dali::Actor arg3 ;
94839   Dali::Actor *argp2 ;
94840   Dali::Actor *argp3 ;
94841
94842   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94843   argp2 = (Dali::Actor *)jarg2;
94844   if (!argp2) {
94845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94846     return ;
94847   }
94848   arg2 = *argp2;
94849   argp3 = (Dali::Actor *)jarg3;
94850   if (!argp3) {
94851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94852     return ;
94853   }
94854   arg3 = *argp3;
94855   {
94856     try {
94857       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
94858     } catch (std::out_of_range& e) {
94859       {
94860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94861       };
94862     } catch (std::exception& e) {
94863       {
94864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94865       };
94866     } catch (Dali::DaliException e) {
94867       {
94868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94869       };
94870     } catch (...) {
94871       {
94872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94873       };
94874     }
94875   }
94876
94877 }
94878
94879
94880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
94881   void * jresult ;
94882   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
94883
94884   {
94885     try {
94886       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
94887     } catch (std::out_of_range& e) {
94888       {
94889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94890       };
94891     } catch (std::exception& e) {
94892       {
94893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94894       };
94895     } catch (Dali::DaliException e) {
94896       {
94897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94898       };
94899     } catch (...) {
94900       {
94901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94902       };
94903     }
94904   }
94905
94906   jresult = (void *)result;
94907   return jresult;
94908 }
94909
94910
94911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
94912   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94913
94914   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94915   {
94916     try {
94917       delete arg1;
94918     } catch (std::out_of_range& e) {
94919       {
94920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94921       };
94922     } catch (std::exception& e) {
94923       {
94924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94925       };
94926     } catch (Dali::DaliException e) {
94927       {
94928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94929       };
94930     } catch (...) {
94931       {
94932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94933       };
94934     }
94935   }
94936
94937 }
94938
94939
94940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
94941   unsigned int jresult ;
94942   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94943   bool result;
94944
94945   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94946   {
94947     try {
94948       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
94949     } catch (std::out_of_range& e) {
94950       {
94951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94952       };
94953     } catch (std::exception& e) {
94954       {
94955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94956       };
94957     } catch (Dali::DaliException e) {
94958       {
94959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94960       };
94961     } catch (...) {
94962       {
94963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94964       };
94965     }
94966   }
94967
94968   jresult = result;
94969   return jresult;
94970 }
94971
94972
94973 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
94974   unsigned long jresult ;
94975   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94976   std::size_t result;
94977
94978   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94979   {
94980     try {
94981       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
94982     } catch (std::out_of_range& e) {
94983       {
94984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94985       };
94986     } catch (std::exception& e) {
94987       {
94988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94989       };
94990     } catch (Dali::DaliException e) {
94991       {
94992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94993       };
94994     } catch (...) {
94995       {
94996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94997       };
94998     }
94999   }
95000
95001   jresult = (unsigned long)result;
95002   return jresult;
95003 }
95004
95005
95006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
95007   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95008   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
95009
95010   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95011   arg2 = (void (*)(Dali::Actor,bool))jarg2;
95012   {
95013     try {
95014       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
95015     } catch (std::out_of_range& e) {
95016       {
95017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95018       };
95019     } catch (std::exception& e) {
95020       {
95021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95022       };
95023     } catch (Dali::DaliException e) {
95024       {
95025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95026       };
95027     } catch (...) {
95028       {
95029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95030       };
95031     }
95032   }
95033
95034 }
95035
95036
95037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95038   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95039   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
95040
95041   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95042   arg2 = (void (*)(Dali::Actor,bool))jarg2;
95043   {
95044     try {
95045       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
95046     } catch (std::out_of_range& e) {
95047       {
95048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95049       };
95050     } catch (std::exception& e) {
95051       {
95052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95053       };
95054     } catch (Dali::DaliException e) {
95055       {
95056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95057       };
95058     } catch (...) {
95059       {
95060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95061       };
95062     }
95063   }
95064
95065 }
95066
95067
95068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
95069   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95070   Dali::Actor arg2 ;
95071   bool arg3 ;
95072   Dali::Actor *argp2 ;
95073
95074   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95075   argp2 = (Dali::Actor *)jarg2;
95076   if (!argp2) {
95077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95078     return ;
95079   }
95080   arg2 = *argp2;
95081   arg3 = jarg3 ? true : false;
95082   {
95083     try {
95084       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
95085     } catch (std::out_of_range& e) {
95086       {
95087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95088       };
95089     } catch (std::exception& e) {
95090       {
95091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95092       };
95093     } catch (Dali::DaliException e) {
95094       {
95095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95096       };
95097     } catch (...) {
95098       {
95099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95100       };
95101     }
95102   }
95103
95104 }
95105
95106
95107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
95108   void * jresult ;
95109   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
95110
95111   {
95112     try {
95113       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
95114     } catch (std::out_of_range& e) {
95115       {
95116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95117       };
95118     } catch (std::exception& e) {
95119       {
95120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95121       };
95122     } catch (Dali::DaliException e) {
95123       {
95124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95125       };
95126     } catch (...) {
95127       {
95128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95129       };
95130     }
95131   }
95132
95133   jresult = (void *)result;
95134   return jresult;
95135 }
95136
95137
95138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
95139   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95140
95141   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95142   {
95143     try {
95144       delete arg1;
95145     } catch (std::out_of_range& e) {
95146       {
95147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95148       };
95149     } catch (std::exception& e) {
95150       {
95151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95152       };
95153     } catch (Dali::DaliException e) {
95154       {
95155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95156       };
95157     } catch (...) {
95158       {
95159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95160       };
95161     }
95162   }
95163
95164 }
95165
95166
95167 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
95168   unsigned int jresult ;
95169   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95170   bool result;
95171
95172   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95173   {
95174     try {
95175       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);
95176     } catch (std::out_of_range& e) {
95177       {
95178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95179       };
95180     } catch (std::exception& e) {
95181       {
95182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95183       };
95184     } catch (Dali::DaliException e) {
95185       {
95186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95187       };
95188     } catch (...) {
95189       {
95190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95191       };
95192     }
95193   }
95194
95195   jresult = result;
95196   return jresult;
95197 }
95198
95199
95200 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
95201   unsigned long jresult ;
95202   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95203   std::size_t result;
95204
95205   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95206   {
95207     try {
95208       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);
95209     } catch (std::out_of_range& e) {
95210       {
95211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95212       };
95213     } catch (std::exception& e) {
95214       {
95215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95216       };
95217     } catch (Dali::DaliException e) {
95218       {
95219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95220       };
95221     } catch (...) {
95222       {
95223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95224       };
95225     }
95226   }
95227
95228   jresult = (unsigned long)result;
95229   return jresult;
95230 }
95231
95232
95233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
95234   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95235   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
95236
95237   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95238   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
95239   {
95240     try {
95241       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
95242     } catch (std::out_of_range& e) {
95243       {
95244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95245       };
95246     } catch (std::exception& e) {
95247       {
95248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95249       };
95250     } catch (Dali::DaliException e) {
95251       {
95252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95253       };
95254     } catch (...) {
95255       {
95256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95257       };
95258     }
95259   }
95260
95261 }
95262
95263
95264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95265   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95266   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
95267
95268   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95269   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
95270   {
95271     try {
95272       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
95273     } catch (std::out_of_range& e) {
95274       {
95275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95276       };
95277     } catch (std::exception& e) {
95278       {
95279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95280       };
95281     } catch (Dali::DaliException e) {
95282       {
95283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95284       };
95285     } catch (...) {
95286       {
95287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95288       };
95289     }
95290   }
95291
95292 }
95293
95294
95295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95296   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95297   Dali::Toolkit::StyleManager arg2 ;
95298   Dali::StyleChange::Type arg3 ;
95299   Dali::Toolkit::StyleManager *argp2 ;
95300
95301   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95302   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
95303   if (!argp2) {
95304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
95305     return ;
95306   }
95307   arg2 = *argp2;
95308   arg3 = (Dali::StyleChange::Type)jarg3;
95309   {
95310     try {
95311       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
95312     } catch (std::out_of_range& e) {
95313       {
95314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95315       };
95316     } catch (std::exception& e) {
95317       {
95318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95319       };
95320     } catch (Dali::DaliException e) {
95321       {
95322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95323       };
95324     } catch (...) {
95325       {
95326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95327       };
95328     }
95329   }
95330
95331 }
95332
95333
95334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
95335   void * jresult ;
95336   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
95337
95338   {
95339     try {
95340       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
95341     } catch (std::out_of_range& e) {
95342       {
95343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95344       };
95345     } catch (std::exception& e) {
95346       {
95347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95348       };
95349     } catch (Dali::DaliException e) {
95350       {
95351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95352       };
95353     } catch (...) {
95354       {
95355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95356       };
95357     }
95358   }
95359
95360   jresult = (void *)result;
95361   return jresult;
95362 }
95363
95364
95365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
95366   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95367
95368   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95369   {
95370     try {
95371       delete arg1;
95372     } catch (std::out_of_range& e) {
95373       {
95374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95375       };
95376     } catch (std::exception& e) {
95377       {
95378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95379       };
95380     } catch (Dali::DaliException e) {
95381       {
95382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95383       };
95384     } catch (...) {
95385       {
95386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95387       };
95388     }
95389   }
95390
95391 }
95392
95393
95394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
95395   unsigned int jresult ;
95396   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95397   bool result;
95398
95399   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95400   {
95401     try {
95402       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
95403     } catch (std::out_of_range& e) {
95404       {
95405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95406       };
95407     } catch (std::exception& e) {
95408       {
95409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95410       };
95411     } catch (Dali::DaliException e) {
95412       {
95413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95414       };
95415     } catch (...) {
95416       {
95417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95418       };
95419     }
95420   }
95421
95422   jresult = result;
95423   return jresult;
95424 }
95425
95426
95427 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
95428   unsigned long jresult ;
95429   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95430   std::size_t result;
95431
95432   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95433   {
95434     try {
95435       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
95436     } catch (std::out_of_range& e) {
95437       {
95438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95439       };
95440     } catch (std::exception& e) {
95441       {
95442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95443       };
95444     } catch (Dali::DaliException e) {
95445       {
95446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95447       };
95448     } catch (...) {
95449       {
95450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95451       };
95452     }
95453   }
95454
95455   jresult = (unsigned long)result;
95456   return jresult;
95457 }
95458
95459
95460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
95461   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95462   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
95463
95464   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95465   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
95466   {
95467     try {
95468       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
95469     } catch (std::out_of_range& e) {
95470       {
95471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95472       };
95473     } catch (std::exception& e) {
95474       {
95475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95476       };
95477     } catch (Dali::DaliException e) {
95478       {
95479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95480       };
95481     } catch (...) {
95482       {
95483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95484       };
95485     }
95486   }
95487
95488 }
95489
95490
95491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
95492   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95493   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
95494
95495   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95496   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
95497   {
95498     try {
95499       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
95500     } catch (std::out_of_range& e) {
95501       {
95502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95503       };
95504     } catch (std::exception& e) {
95505       {
95506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95507       };
95508     } catch (Dali::DaliException e) {
95509       {
95510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95511       };
95512     } catch (...) {
95513       {
95514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95515       };
95516     }
95517   }
95518
95519 }
95520
95521
95522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
95523   unsigned int jresult ;
95524   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95525   Dali::Toolkit::Button arg2 ;
95526   Dali::Toolkit::Button *argp2 ;
95527   bool result;
95528
95529   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95530   argp2 = (Dali::Toolkit::Button *)jarg2;
95531   if (!argp2) {
95532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
95533     return 0;
95534   }
95535   arg2 = *argp2;
95536   {
95537     try {
95538       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
95539     } catch (std::out_of_range& e) {
95540       {
95541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95542       };
95543     } catch (std::exception& e) {
95544       {
95545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95546       };
95547     } catch (Dali::DaliException e) {
95548       {
95549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95550       };
95551     } catch (...) {
95552       {
95553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95554       };
95555     }
95556   }
95557
95558   jresult = result;
95559   return jresult;
95560 }
95561
95562
95563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
95564   void * jresult ;
95565   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
95566
95567   {
95568     try {
95569       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
95570     } catch (std::out_of_range& e) {
95571       {
95572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95573       };
95574     } catch (std::exception& e) {
95575       {
95576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95577       };
95578     } catch (Dali::DaliException e) {
95579       {
95580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95581       };
95582     } catch (...) {
95583       {
95584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95585       };
95586     }
95587   }
95588
95589   jresult = (void *)result;
95590   return jresult;
95591 }
95592
95593
95594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
95595   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95596
95597   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95598   {
95599     try {
95600       delete arg1;
95601     } catch (std::out_of_range& e) {
95602       {
95603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95604       };
95605     } catch (std::exception& e) {
95606       {
95607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95608       };
95609     } catch (Dali::DaliException e) {
95610       {
95611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95612       };
95613     } catch (...) {
95614       {
95615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95616       };
95617     }
95618   }
95619
95620 }
95621
95622
95623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
95624   unsigned int jresult ;
95625   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95626   bool result;
95627
95628   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95629   {
95630     try {
95631       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
95632     } catch (std::out_of_range& e) {
95633       {
95634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95635       };
95636     } catch (std::exception& e) {
95637       {
95638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95639       };
95640     } catch (Dali::DaliException e) {
95641       {
95642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95643       };
95644     } catch (...) {
95645       {
95646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95647       };
95648     }
95649   }
95650
95651   jresult = result;
95652   return jresult;
95653 }
95654
95655
95656 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
95657   unsigned long jresult ;
95658   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95659   std::size_t result;
95660
95661   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95662   {
95663     try {
95664       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
95665     } catch (std::out_of_range& e) {
95666       {
95667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95668       };
95669     } catch (std::exception& e) {
95670       {
95671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95672       };
95673     } catch (Dali::DaliException e) {
95674       {
95675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95676       };
95677     } catch (...) {
95678       {
95679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95680       };
95681     }
95682   }
95683
95684   jresult = (unsigned long)result;
95685   return jresult;
95686 }
95687
95688
95689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
95690   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95691   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
95692
95693   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95694   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
95695   {
95696     try {
95697       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
95698     } catch (std::out_of_range& e) {
95699       {
95700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95701       };
95702     } catch (std::exception& e) {
95703       {
95704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95705       };
95706     } catch (Dali::DaliException e) {
95707       {
95708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95709       };
95710     } catch (...) {
95711       {
95712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95713       };
95714     }
95715   }
95716
95717 }
95718
95719
95720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
95721   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95722   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
95723
95724   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95725   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
95726   {
95727     try {
95728       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
95729     } catch (std::out_of_range& e) {
95730       {
95731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95732       };
95733     } catch (std::exception& e) {
95734       {
95735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95736       };
95737     } catch (Dali::DaliException e) {
95738       {
95739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95740       };
95741     } catch (...) {
95742       {
95743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95744       };
95745     }
95746   }
95747
95748 }
95749
95750
95751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
95752   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95753   Dali::Toolkit::GaussianBlurView arg2 ;
95754   Dali::Toolkit::GaussianBlurView *argp2 ;
95755
95756   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95757   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
95758   if (!argp2) {
95759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
95760     return ;
95761   }
95762   arg2 = *argp2;
95763   {
95764     try {
95765       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
95766     } catch (std::out_of_range& e) {
95767       {
95768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95769       };
95770     } catch (std::exception& e) {
95771       {
95772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95773       };
95774     } catch (Dali::DaliException e) {
95775       {
95776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95777       };
95778     } catch (...) {
95779       {
95780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95781       };
95782     }
95783   }
95784
95785 }
95786
95787
95788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
95789   void * jresult ;
95790   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
95791
95792   {
95793     try {
95794       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
95795     } catch (std::out_of_range& e) {
95796       {
95797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95798       };
95799     } catch (std::exception& e) {
95800       {
95801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95802       };
95803     } catch (Dali::DaliException e) {
95804       {
95805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95806       };
95807     } catch (...) {
95808       {
95809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95810       };
95811     }
95812   }
95813
95814   jresult = (void *)result;
95815   return jresult;
95816 }
95817
95818
95819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
95820   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95821
95822   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95823   {
95824     try {
95825       delete arg1;
95826     } catch (std::out_of_range& e) {
95827       {
95828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95829       };
95830     } catch (std::exception& e) {
95831       {
95832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95833       };
95834     } catch (Dali::DaliException e) {
95835       {
95836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95837       };
95838     } catch (...) {
95839       {
95840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95841       };
95842     }
95843   }
95844
95845 }
95846
95847
95848 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
95849   unsigned int jresult ;
95850   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95851   bool result;
95852
95853   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95854   {
95855     try {
95856       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);
95857     } catch (std::out_of_range& e) {
95858       {
95859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95860       };
95861     } catch (std::exception& e) {
95862       {
95863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95864       };
95865     } catch (Dali::DaliException e) {
95866       {
95867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95868       };
95869     } catch (...) {
95870       {
95871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95872       };
95873     }
95874   }
95875
95876   jresult = result;
95877   return jresult;
95878 }
95879
95880
95881 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
95882   unsigned long jresult ;
95883   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95884   std::size_t result;
95885
95886   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95887   {
95888     try {
95889       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);
95890     } catch (std::out_of_range& e) {
95891       {
95892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95893       };
95894     } catch (std::exception& e) {
95895       {
95896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95897       };
95898     } catch (Dali::DaliException e) {
95899       {
95900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95901       };
95902     } catch (...) {
95903       {
95904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95905       };
95906     }
95907   }
95908
95909   jresult = (unsigned long)result;
95910   return jresult;
95911 }
95912
95913
95914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
95915   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95916   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
95917
95918   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95919   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
95920   {
95921     try {
95922       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
95923     } catch (std::out_of_range& e) {
95924       {
95925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95926       };
95927     } catch (std::exception& e) {
95928       {
95929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95930       };
95931     } catch (Dali::DaliException e) {
95932       {
95933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95934       };
95935     } catch (...) {
95936       {
95937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95938       };
95939     }
95940   }
95941
95942 }
95943
95944
95945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
95946   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95947   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
95948
95949   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95950   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
95951   {
95952     try {
95953       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
95954     } catch (std::out_of_range& e) {
95955       {
95956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95957       };
95958     } catch (std::exception& e) {
95959       {
95960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95961       };
95962     } catch (Dali::DaliException e) {
95963       {
95964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95965       };
95966     } catch (...) {
95967       {
95968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95969       };
95970     }
95971   }
95972
95973 }
95974
95975
95976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
95977   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95978   Dali::Toolkit::PageTurnView arg2 ;
95979   unsigned int arg3 ;
95980   bool arg4 ;
95981   Dali::Toolkit::PageTurnView *argp2 ;
95982
95983   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95984   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
95985   if (!argp2) {
95986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
95987     return ;
95988   }
95989   arg2 = *argp2;
95990   arg3 = (unsigned int)jarg3;
95991   arg4 = jarg4 ? true : false;
95992   {
95993     try {
95994       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
95995     } catch (std::out_of_range& e) {
95996       {
95997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95998       };
95999     } catch (std::exception& e) {
96000       {
96001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96002       };
96003     } catch (Dali::DaliException e) {
96004       {
96005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96006       };
96007     } catch (...) {
96008       {
96009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96010       };
96011     }
96012   }
96013
96014 }
96015
96016
96017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
96018   void * jresult ;
96019   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
96020
96021   {
96022     try {
96023       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
96024     } catch (std::out_of_range& e) {
96025       {
96026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96027       };
96028     } catch (std::exception& e) {
96029       {
96030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96031       };
96032     } catch (Dali::DaliException e) {
96033       {
96034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96035       };
96036     } catch (...) {
96037       {
96038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96039       };
96040     }
96041   }
96042
96043   jresult = (void *)result;
96044   return jresult;
96045 }
96046
96047
96048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
96049   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96050
96051   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96052   {
96053     try {
96054       delete arg1;
96055     } catch (std::out_of_range& e) {
96056       {
96057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96058       };
96059     } catch (std::exception& e) {
96060       {
96061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96062       };
96063     } catch (Dali::DaliException e) {
96064       {
96065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96066       };
96067     } catch (...) {
96068       {
96069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96070       };
96071     }
96072   }
96073
96074 }
96075
96076
96077 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
96078   unsigned int jresult ;
96079   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96080   bool result;
96081
96082   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96083   {
96084     try {
96085       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
96086     } catch (std::out_of_range& e) {
96087       {
96088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96089       };
96090     } catch (std::exception& e) {
96091       {
96092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96093       };
96094     } catch (Dali::DaliException e) {
96095       {
96096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96097       };
96098     } catch (...) {
96099       {
96100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96101       };
96102     }
96103   }
96104
96105   jresult = result;
96106   return jresult;
96107 }
96108
96109
96110 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
96111   unsigned long jresult ;
96112   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96113   std::size_t result;
96114
96115   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96116   {
96117     try {
96118       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
96119     } catch (std::out_of_range& e) {
96120       {
96121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96122       };
96123     } catch (std::exception& e) {
96124       {
96125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96126       };
96127     } catch (Dali::DaliException e) {
96128       {
96129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96130       };
96131     } catch (...) {
96132       {
96133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96134       };
96135     }
96136   }
96137
96138   jresult = (unsigned long)result;
96139   return jresult;
96140 }
96141
96142
96143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
96144   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96145   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
96146
96147   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96148   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
96149   {
96150     try {
96151       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
96152     } catch (std::out_of_range& e) {
96153       {
96154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96155       };
96156     } catch (std::exception& e) {
96157       {
96158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96159       };
96160     } catch (Dali::DaliException e) {
96161       {
96162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96163       };
96164     } catch (...) {
96165       {
96166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96167       };
96168     }
96169   }
96170
96171 }
96172
96173
96174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
96175   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96176   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
96177
96178   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96179   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
96180   {
96181     try {
96182       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
96183     } catch (std::out_of_range& e) {
96184       {
96185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96186       };
96187     } catch (std::exception& e) {
96188       {
96189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96190       };
96191     } catch (Dali::DaliException e) {
96192       {
96193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96194       };
96195     } catch (...) {
96196       {
96197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96198       };
96199     }
96200   }
96201
96202 }
96203
96204
96205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
96206   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96207   Dali::Toolkit::PageTurnView arg2 ;
96208   Dali::Toolkit::PageTurnView *argp2 ;
96209
96210   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96211   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
96212   if (!argp2) {
96213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
96214     return ;
96215   }
96216   arg2 = *argp2;
96217   {
96218     try {
96219       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
96220     } catch (std::out_of_range& e) {
96221       {
96222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96223       };
96224     } catch (std::exception& e) {
96225       {
96226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96227       };
96228     } catch (Dali::DaliException e) {
96229       {
96230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96231       };
96232     } catch (...) {
96233       {
96234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96235       };
96236     }
96237   }
96238
96239 }
96240
96241
96242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
96243   void * jresult ;
96244   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
96245
96246   {
96247     try {
96248       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
96249     } catch (std::out_of_range& e) {
96250       {
96251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96252       };
96253     } catch (std::exception& e) {
96254       {
96255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96256       };
96257     } catch (Dali::DaliException e) {
96258       {
96259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96260       };
96261     } catch (...) {
96262       {
96263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96264       };
96265     }
96266   }
96267
96268   jresult = (void *)result;
96269   return jresult;
96270 }
96271
96272
96273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
96274   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96275
96276   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96277   {
96278     try {
96279       delete arg1;
96280     } catch (std::out_of_range& e) {
96281       {
96282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96283       };
96284     } catch (std::exception& e) {
96285       {
96286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96287       };
96288     } catch (Dali::DaliException e) {
96289       {
96290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96291       };
96292     } catch (...) {
96293       {
96294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96295       };
96296     }
96297   }
96298
96299 }
96300
96301
96302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
96303   unsigned int jresult ;
96304   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96305   bool result;
96306
96307   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96308   {
96309     try {
96310       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);
96311     } catch (std::out_of_range& e) {
96312       {
96313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96314       };
96315     } catch (std::exception& e) {
96316       {
96317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96318       };
96319     } catch (Dali::DaliException e) {
96320       {
96321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96322       };
96323     } catch (...) {
96324       {
96325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96326       };
96327     }
96328   }
96329
96330   jresult = result;
96331   return jresult;
96332 }
96333
96334
96335 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
96336   unsigned long jresult ;
96337   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96338   std::size_t result;
96339
96340   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96341   {
96342     try {
96343       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);
96344     } catch (std::out_of_range& e) {
96345       {
96346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96347       };
96348     } catch (std::exception& e) {
96349       {
96350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96351       };
96352     } catch (Dali::DaliException e) {
96353       {
96354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96355       };
96356     } catch (...) {
96357       {
96358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96359       };
96360     }
96361   }
96362
96363   jresult = (unsigned long)result;
96364   return jresult;
96365 }
96366
96367
96368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
96369   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96370   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
96371
96372   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96373   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
96374   {
96375     try {
96376       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
96377     } catch (std::out_of_range& e) {
96378       {
96379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96380       };
96381     } catch (std::exception& e) {
96382       {
96383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96384       };
96385     } catch (Dali::DaliException e) {
96386       {
96387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96388       };
96389     } catch (...) {
96390       {
96391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96392       };
96393     }
96394   }
96395
96396 }
96397
96398
96399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96400   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96401   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
96402
96403   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96404   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
96405   {
96406     try {
96407       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
96408     } catch (std::out_of_range& e) {
96409       {
96410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96411       };
96412     } catch (std::exception& e) {
96413       {
96414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96415       };
96416     } catch (Dali::DaliException e) {
96417       {
96418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96419       };
96420     } catch (...) {
96421       {
96422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96423       };
96424     }
96425   }
96426
96427 }
96428
96429
96430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
96431   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96432   Dali::Toolkit::ProgressBar arg2 ;
96433   float arg3 ;
96434   float arg4 ;
96435   Dali::Toolkit::ProgressBar *argp2 ;
96436
96437   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96438   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
96439   if (!argp2) {
96440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
96441     return ;
96442   }
96443   arg2 = *argp2;
96444   arg3 = (float)jarg3;
96445   arg4 = (float)jarg4;
96446   {
96447     try {
96448       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
96449     } catch (std::out_of_range& e) {
96450       {
96451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96452       };
96453     } catch (std::exception& e) {
96454       {
96455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96456       };
96457     } catch (Dali::DaliException e) {
96458       {
96459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96460       };
96461     } catch (...) {
96462       {
96463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96464       };
96465     }
96466   }
96467
96468 }
96469
96470
96471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
96472   void * jresult ;
96473   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
96474
96475   {
96476     try {
96477       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
96478     } catch (std::out_of_range& e) {
96479       {
96480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96481       };
96482     } catch (std::exception& e) {
96483       {
96484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96485       };
96486     } catch (Dali::DaliException e) {
96487       {
96488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96489       };
96490     } catch (...) {
96491       {
96492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96493       };
96494     }
96495   }
96496
96497   jresult = (void *)result;
96498   return jresult;
96499 }
96500
96501
96502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
96503   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96504
96505   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96506   {
96507     try {
96508       delete arg1;
96509     } catch (std::out_of_range& e) {
96510       {
96511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96512       };
96513     } catch (std::exception& e) {
96514       {
96515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96516       };
96517     } catch (Dali::DaliException e) {
96518       {
96519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96520       };
96521     } catch (...) {
96522       {
96523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96524       };
96525     }
96526   }
96527
96528 }
96529
96530
96531 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
96532   unsigned int jresult ;
96533   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96534   bool result;
96535
96536   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96537   {
96538     try {
96539       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);
96540     } catch (std::out_of_range& e) {
96541       {
96542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96543       };
96544     } catch (std::exception& e) {
96545       {
96546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96547       };
96548     } catch (Dali::DaliException e) {
96549       {
96550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96551       };
96552     } catch (...) {
96553       {
96554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96555       };
96556     }
96557   }
96558
96559   jresult = result;
96560   return jresult;
96561 }
96562
96563
96564 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
96565   unsigned long jresult ;
96566   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96567   std::size_t result;
96568
96569   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96570   {
96571     try {
96572       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);
96573     } catch (std::out_of_range& e) {
96574       {
96575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96576       };
96577     } catch (std::exception& e) {
96578       {
96579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96580       };
96581     } catch (Dali::DaliException e) {
96582       {
96583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96584       };
96585     } catch (...) {
96586       {
96587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96588       };
96589     }
96590   }
96591
96592   jresult = (unsigned long)result;
96593   return jresult;
96594 }
96595
96596
96597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
96598   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96599   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
96600
96601   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96602   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
96603   {
96604     try {
96605       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
96606     } catch (std::out_of_range& e) {
96607       {
96608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96609       };
96610     } catch (std::exception& e) {
96611       {
96612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96613       };
96614     } catch (Dali::DaliException e) {
96615       {
96616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96617       };
96618     } catch (...) {
96619       {
96620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96621       };
96622     }
96623   }
96624
96625 }
96626
96627
96628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
96629   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96630   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
96631
96632   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96633   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
96634   {
96635     try {
96636       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
96637     } catch (std::out_of_range& e) {
96638       {
96639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96640       };
96641     } catch (std::exception& e) {
96642       {
96643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96644       };
96645     } catch (Dali::DaliException e) {
96646       {
96647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96648       };
96649     } catch (...) {
96650       {
96651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96652       };
96653     }
96654   }
96655
96656 }
96657
96658
96659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
96660   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96661   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
96662
96663   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96664   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
96665   if (!arg2) {
96666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
96667     return ;
96668   }
96669   {
96670     try {
96671       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
96672     } catch (std::out_of_range& e) {
96673       {
96674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96675       };
96676     } catch (std::exception& e) {
96677       {
96678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96679       };
96680     } catch (Dali::DaliException e) {
96681       {
96682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96683       };
96684     } catch (...) {
96685       {
96686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96687       };
96688     }
96689   }
96690
96691 }
96692
96693
96694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
96695   void * jresult ;
96696   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
96697
96698   {
96699     try {
96700       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
96701     } catch (std::out_of_range& e) {
96702       {
96703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96704       };
96705     } catch (std::exception& e) {
96706       {
96707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96708       };
96709     } catch (Dali::DaliException e) {
96710       {
96711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96712       };
96713     } catch (...) {
96714       {
96715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96716       };
96717     }
96718   }
96719
96720   jresult = (void *)result;
96721   return jresult;
96722 }
96723
96724
96725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
96726   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96727
96728   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96729   {
96730     try {
96731       delete arg1;
96732     } catch (std::out_of_range& e) {
96733       {
96734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96735       };
96736     } catch (std::exception& e) {
96737       {
96738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96739       };
96740     } catch (Dali::DaliException e) {
96741       {
96742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96743       };
96744     } catch (...) {
96745       {
96746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96747       };
96748     }
96749   }
96750
96751 }
96752
96753
96754 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
96755   unsigned int jresult ;
96756   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96757   bool result;
96758
96759   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96760   {
96761     try {
96762       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
96763     } catch (std::out_of_range& e) {
96764       {
96765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96766       };
96767     } catch (std::exception& e) {
96768       {
96769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96770       };
96771     } catch (Dali::DaliException e) {
96772       {
96773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96774       };
96775     } catch (...) {
96776       {
96777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96778       };
96779     }
96780   }
96781
96782   jresult = result;
96783   return jresult;
96784 }
96785
96786
96787 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
96788   unsigned long jresult ;
96789   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96790   std::size_t result;
96791
96792   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96793   {
96794     try {
96795       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
96796     } catch (std::out_of_range& e) {
96797       {
96798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96799       };
96800     } catch (std::exception& e) {
96801       {
96802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96803       };
96804     } catch (Dali::DaliException e) {
96805       {
96806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96807       };
96808     } catch (...) {
96809       {
96810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96811       };
96812     }
96813   }
96814
96815   jresult = (unsigned long)result;
96816   return jresult;
96817 }
96818
96819
96820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
96821   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96822   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
96823
96824   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96825   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
96826   {
96827     try {
96828       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
96829     } catch (std::out_of_range& e) {
96830       {
96831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96832       };
96833     } catch (std::exception& e) {
96834       {
96835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96836       };
96837     } catch (Dali::DaliException e) {
96838       {
96839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96840       };
96841     } catch (...) {
96842       {
96843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96844       };
96845     }
96846   }
96847
96848 }
96849
96850
96851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
96852   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96853   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
96854
96855   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96856   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
96857   {
96858     try {
96859       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
96860     } catch (std::out_of_range& e) {
96861       {
96862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96863       };
96864     } catch (std::exception& e) {
96865       {
96866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96867       };
96868     } catch (Dali::DaliException e) {
96869       {
96870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96871       };
96872     } catch (...) {
96873       {
96874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96875       };
96876     }
96877   }
96878
96879 }
96880
96881
96882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
96883   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96884   Dali::Vector2 *arg2 = 0 ;
96885
96886   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96887   arg2 = (Dali::Vector2 *)jarg2;
96888   if (!arg2) {
96889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
96890     return ;
96891   }
96892   {
96893     try {
96894       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
96895     } catch (std::out_of_range& e) {
96896       {
96897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96898       };
96899     } catch (std::exception& e) {
96900       {
96901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96902       };
96903     } catch (Dali::DaliException e) {
96904       {
96905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96906       };
96907     } catch (...) {
96908       {
96909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96910       };
96911     }
96912   }
96913
96914 }
96915
96916
96917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
96918   void * jresult ;
96919   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
96920
96921   {
96922     try {
96923       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
96924     } catch (std::out_of_range& e) {
96925       {
96926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96927       };
96928     } catch (std::exception& e) {
96929       {
96930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96931       };
96932     } catch (Dali::DaliException e) {
96933       {
96934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96935       };
96936     } catch (...) {
96937       {
96938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96939       };
96940     }
96941   }
96942
96943   jresult = (void *)result;
96944   return jresult;
96945 }
96946
96947
96948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
96949   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96950
96951   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96952   {
96953     try {
96954       delete arg1;
96955     } catch (std::out_of_range& e) {
96956       {
96957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96958       };
96959     } catch (std::exception& e) {
96960       {
96961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96962       };
96963     } catch (Dali::DaliException e) {
96964       {
96965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96966       };
96967     } catch (...) {
96968       {
96969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96970       };
96971     }
96972   }
96973
96974 }
96975
96976
96977
96978 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
96979   unsigned int jresult ;
96980   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96981   bool result;
96982
96983   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96984   {
96985     try {
96986       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);
96987     } catch (std::out_of_range& e) {
96988       {
96989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96990       };
96991     } catch (std::exception& e) {
96992       {
96993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96994       };
96995     } catch (Dali::DaliException e) {
96996       {
96997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96998       };
96999     } catch (...) {
97000       {
97001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97002       };
97003     }
97004   }
97005
97006   jresult = result;
97007   return jresult;
97008 }
97009
97010
97011 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
97012   unsigned long jresult ;
97013   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97014   std::size_t result;
97015
97016   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97017   {
97018     try {
97019       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);
97020     } catch (std::out_of_range& e) {
97021       {
97022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97023       };
97024     } catch (std::exception& e) {
97025       {
97026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97027       };
97028     } catch (Dali::DaliException e) {
97029       {
97030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97031       };
97032     } catch (...) {
97033       {
97034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97035       };
97036     }
97037   }
97038
97039   jresult = (unsigned long)result;
97040   return jresult;
97041 }
97042
97043
97044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
97045   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97046   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
97047
97048   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97049   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
97050   {
97051     try {
97052       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97053     } catch (std::out_of_range& e) {
97054       {
97055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97056       };
97057     } catch (std::exception& e) {
97058       {
97059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97060       };
97061     } catch (Dali::DaliException e) {
97062       {
97063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97064       };
97065     } catch (...) {
97066       {
97067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97068       };
97069     }
97070   }
97071
97072 }
97073
97074
97075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
97076   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97077   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
97078
97079   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97080   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
97081   {
97082     try {
97083       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97084     } catch (std::out_of_range& e) {
97085       {
97086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97087       };
97088     } catch (std::exception& e) {
97089       {
97090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97091       };
97092     } catch (Dali::DaliException e) {
97093       {
97094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97095       };
97096     } catch (...) {
97097       {
97098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97099       };
97100     }
97101   }
97102
97103 }
97104
97105
97106 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
97107   unsigned int jresult ;
97108   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97109   Dali::Toolkit::Control arg2 ;
97110   Dali::KeyEvent *arg3 = 0 ;
97111   Dali::Toolkit::Control *argp2 ;
97112   bool result;
97113
97114   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97115   argp2 = (Dali::Toolkit::Control *)jarg2;
97116   if (!argp2) {
97117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
97118     return 0;
97119   }
97120   arg2 = *argp2;
97121   arg3 = (Dali::KeyEvent *)jarg3;
97122   if (!arg3) {
97123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
97124     return 0;
97125   }
97126   {
97127     try {
97128       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);
97129     } catch (std::out_of_range& e) {
97130       {
97131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97132       };
97133     } catch (std::exception& e) {
97134       {
97135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97136       };
97137     } catch (Dali::DaliException e) {
97138       {
97139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97140       };
97141     } catch (...) {
97142       {
97143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97144       };
97145     }
97146   }
97147
97148   jresult = result;
97149   return jresult;
97150 }
97151
97152
97153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
97154   void * jresult ;
97155   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
97156
97157   {
97158     try {
97159       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
97160     } catch (std::out_of_range& e) {
97161       {
97162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97163       };
97164     } catch (std::exception& e) {
97165       {
97166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97167       };
97168     } catch (Dali::DaliException e) {
97169       {
97170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97171       };
97172     } catch (...) {
97173       {
97174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97175       };
97176     }
97177   }
97178
97179   jresult = (void *)result;
97180   return jresult;
97181 }
97182
97183
97184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
97185   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97186
97187   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97188   {
97189     try {
97190       delete arg1;
97191     } catch (std::out_of_range& e) {
97192       {
97193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97194       };
97195     } catch (std::exception& e) {
97196       {
97197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97198       };
97199     } catch (Dali::DaliException e) {
97200       {
97201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97202       };
97203     } catch (...) {
97204       {
97205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97206       };
97207     }
97208   }
97209
97210 }
97211
97212
97213 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
97214   unsigned int jresult ;
97215   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97216   bool result;
97217
97218   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97219   {
97220     try {
97221       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97222     } catch (std::out_of_range& e) {
97223       {
97224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97225       };
97226     } catch (std::exception& e) {
97227       {
97228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97229       };
97230     } catch (Dali::DaliException e) {
97231       {
97232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97233       };
97234     } catch (...) {
97235       {
97236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97237       };
97238     }
97239   }
97240
97241   jresult = result;
97242   return jresult;
97243 }
97244
97245
97246 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
97247   unsigned long jresult ;
97248   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97249   std::size_t result;
97250
97251   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97252   {
97253     try {
97254       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97255     } catch (std::out_of_range& e) {
97256       {
97257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97258       };
97259     } catch (std::exception& e) {
97260       {
97261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97262       };
97263     } catch (Dali::DaliException e) {
97264       {
97265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97266       };
97267     } catch (...) {
97268       {
97269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97270       };
97271     }
97272   }
97273
97274   jresult = (unsigned long)result;
97275   return jresult;
97276 }
97277
97278
97279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
97280   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97281   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
97282
97283   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97284   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
97285   {
97286     try {
97287       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
97288     } catch (std::out_of_range& e) {
97289       {
97290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97291       };
97292     } catch (std::exception& e) {
97293       {
97294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97295       };
97296     } catch (Dali::DaliException e) {
97297       {
97298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97299       };
97300     } catch (...) {
97301       {
97302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97303       };
97304     }
97305   }
97306
97307 }
97308
97309
97310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
97311   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97312   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
97313
97314   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97315   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
97316   {
97317     try {
97318       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
97319     } catch (std::out_of_range& e) {
97320       {
97321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97322       };
97323     } catch (std::exception& e) {
97324       {
97325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97326       };
97327     } catch (Dali::DaliException e) {
97328       {
97329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97330       };
97331     } catch (...) {
97332       {
97333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97334       };
97335     }
97336   }
97337
97338 }
97339
97340
97341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
97342   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97343   Dali::Toolkit::Control arg2 ;
97344   Dali::Toolkit::Control *argp2 ;
97345
97346   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97347   argp2 = (Dali::Toolkit::Control *)jarg2;
97348   if (!argp2) {
97349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
97350     return ;
97351   }
97352   arg2 = *argp2;
97353   {
97354     try {
97355       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
97356     } catch (std::out_of_range& e) {
97357       {
97358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97359       };
97360     } catch (std::exception& e) {
97361       {
97362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97363       };
97364     } catch (Dali::DaliException e) {
97365       {
97366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97367       };
97368     } catch (...) {
97369       {
97370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97371       };
97372     }
97373   }
97374
97375 }
97376
97377
97378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
97379   void * jresult ;
97380   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
97381
97382   {
97383     try {
97384       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
97385     } catch (std::out_of_range& e) {
97386       {
97387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97388       };
97389     } catch (std::exception& e) {
97390       {
97391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97392       };
97393     } catch (Dali::DaliException e) {
97394       {
97395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97396       };
97397     } catch (...) {
97398       {
97399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97400       };
97401     }
97402   }
97403
97404   jresult = (void *)result;
97405   return jresult;
97406 }
97407
97408
97409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
97410   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97411
97412   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97413   {
97414     try {
97415       delete arg1;
97416     } catch (std::out_of_range& e) {
97417       {
97418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97419       };
97420     } catch (std::exception& e) {
97421       {
97422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97423       };
97424     } catch (Dali::DaliException e) {
97425       {
97426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97427       };
97428     } catch (...) {
97429       {
97430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97431       };
97432     }
97433   }
97434
97435 }
97436
97437
97438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
97439   unsigned int jresult ;
97440   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97441   bool result;
97442
97443   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97444   {
97445     try {
97446       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
97447     } catch (std::out_of_range& e) {
97448       {
97449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97450       };
97451     } catch (std::exception& e) {
97452       {
97453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97454       };
97455     } catch (Dali::DaliException e) {
97456       {
97457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97458       };
97459     } catch (...) {
97460       {
97461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97462       };
97463     }
97464   }
97465
97466   jresult = result;
97467   return jresult;
97468 }
97469
97470
97471 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
97472   unsigned long jresult ;
97473   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97474   std::size_t result;
97475
97476   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97477   {
97478     try {
97479       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
97480     } catch (std::out_of_range& e) {
97481       {
97482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97483       };
97484     } catch (std::exception& e) {
97485       {
97486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97487       };
97488     } catch (Dali::DaliException e) {
97489       {
97490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97491       };
97492     } catch (...) {
97493       {
97494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97495       };
97496     }
97497   }
97498
97499   jresult = (unsigned long)result;
97500   return jresult;
97501 }
97502
97503
97504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
97505   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97506   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
97507
97508   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97509   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
97510   {
97511     try {
97512       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
97513     } catch (std::out_of_range& e) {
97514       {
97515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97516       };
97517     } catch (std::exception& e) {
97518       {
97519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97520       };
97521     } catch (Dali::DaliException e) {
97522       {
97523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97524       };
97525     } catch (...) {
97526       {
97527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97528       };
97529     }
97530   }
97531
97532 }
97533
97534
97535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
97536   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97537   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
97538
97539   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97540   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
97541   {
97542     try {
97543       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
97544     } catch (std::out_of_range& e) {
97545       {
97546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97547       };
97548     } catch (std::exception& e) {
97549       {
97550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97551       };
97552     } catch (Dali::DaliException e) {
97553       {
97554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97555       };
97556     } catch (...) {
97557       {
97558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97559       };
97560     }
97561   }
97562
97563 }
97564
97565
97566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
97567   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97568   Dali::Toolkit::VideoView *arg2 = 0 ;
97569
97570   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97571   arg2 = (Dali::Toolkit::VideoView *)jarg2;
97572   if (!arg2) {
97573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
97574     return ;
97575   }
97576   {
97577     try {
97578       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
97579     } catch (std::out_of_range& e) {
97580       {
97581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97582       };
97583     } catch (std::exception& e) {
97584       {
97585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97586       };
97587     } catch (Dali::DaliException e) {
97588       {
97589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97590       };
97591     } catch (...) {
97592       {
97593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97594       };
97595     }
97596   }
97597
97598 }
97599
97600
97601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
97602   void * jresult ;
97603   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
97604
97605   {
97606     try {
97607       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
97608     } catch (std::out_of_range& e) {
97609       {
97610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97611       };
97612     } catch (std::exception& e) {
97613       {
97614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97615       };
97616     } catch (Dali::DaliException e) {
97617       {
97618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97619       };
97620     } catch (...) {
97621       {
97622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97623       };
97624     }
97625   }
97626
97627   jresult = (void *)result;
97628   return jresult;
97629 }
97630
97631
97632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
97633   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97634
97635   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97636   {
97637     try {
97638       delete arg1;
97639     } catch (std::out_of_range& e) {
97640       {
97641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97642       };
97643     } catch (std::exception& e) {
97644       {
97645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97646       };
97647     } catch (Dali::DaliException e) {
97648       {
97649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97650       };
97651     } catch (...) {
97652       {
97653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97654       };
97655     }
97656   }
97657
97658 }
97659
97660
97661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
97662   unsigned int jresult ;
97663   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97664   bool result;
97665
97666   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97667   {
97668     try {
97669       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
97670     } catch (std::out_of_range& e) {
97671       {
97672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97673       };
97674     } catch (std::exception& e) {
97675       {
97676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97677       };
97678     } catch (Dali::DaliException e) {
97679       {
97680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97681       };
97682     } catch (...) {
97683       {
97684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97685       };
97686     }
97687   }
97688
97689   jresult = result;
97690   return jresult;
97691 }
97692
97693
97694 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
97695   unsigned long jresult ;
97696   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97697   std::size_t result;
97698
97699   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97700   {
97701     try {
97702       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
97703     } catch (std::out_of_range& e) {
97704       {
97705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97706       };
97707     } catch (std::exception& e) {
97708       {
97709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97710       };
97711     } catch (Dali::DaliException e) {
97712       {
97713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97714       };
97715     } catch (...) {
97716       {
97717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97718       };
97719     }
97720   }
97721
97722   jresult = (unsigned long)result;
97723   return jresult;
97724 }
97725
97726
97727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97728   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97729   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
97730
97731   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97732   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
97733   {
97734     try {
97735       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
97736     } catch (std::out_of_range& e) {
97737       {
97738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97739       };
97740     } catch (std::exception& e) {
97741       {
97742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97743       };
97744     } catch (Dali::DaliException e) {
97745       {
97746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97747       };
97748     } catch (...) {
97749       {
97750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97751       };
97752     }
97753   }
97754
97755 }
97756
97757
97758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97759   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97760   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
97761
97762   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97763   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
97764   {
97765     try {
97766       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97767     } catch (std::out_of_range& e) {
97768       {
97769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97770       };
97771     } catch (std::exception& e) {
97772       {
97773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97774       };
97775     } catch (Dali::DaliException e) {
97776       {
97777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97778       };
97779     } catch (...) {
97780       {
97781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97782       };
97783     }
97784   }
97785
97786 }
97787
97788
97789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
97790   unsigned int jresult ;
97791   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97792   Dali::Toolkit::Slider arg2 ;
97793   float arg3 ;
97794   Dali::Toolkit::Slider *argp2 ;
97795   bool result;
97796
97797   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97798   argp2 = (Dali::Toolkit::Slider *)jarg2;
97799   if (!argp2) {
97800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
97801     return 0;
97802   }
97803   arg2 = *argp2;
97804   arg3 = (float)jarg3;
97805   {
97806     try {
97807       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
97808     } catch (std::out_of_range& e) {
97809       {
97810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97811       };
97812     } catch (std::exception& e) {
97813       {
97814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97815       };
97816     } catch (Dali::DaliException e) {
97817       {
97818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97819       };
97820     } catch (...) {
97821       {
97822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97823       };
97824     }
97825   }
97826
97827   jresult = result;
97828   return jresult;
97829 }
97830
97831
97832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
97833   void * jresult ;
97834   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
97835
97836   {
97837     try {
97838       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
97839     } catch (std::out_of_range& e) {
97840       {
97841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97842       };
97843     } catch (std::exception& e) {
97844       {
97845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97846       };
97847     } catch (Dali::DaliException e) {
97848       {
97849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97850       };
97851     } catch (...) {
97852       {
97853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97854       };
97855     }
97856   }
97857
97858   jresult = (void *)result;
97859   return jresult;
97860 }
97861
97862
97863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
97864   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97865
97866   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97867   {
97868     try {
97869       delete arg1;
97870     } catch (std::out_of_range& e) {
97871       {
97872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97873       };
97874     } catch (std::exception& e) {
97875       {
97876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97877       };
97878     } catch (Dali::DaliException e) {
97879       {
97880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97881       };
97882     } catch (...) {
97883       {
97884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97885       };
97886     }
97887   }
97888
97889 }
97890
97891
97892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
97893   unsigned int jresult ;
97894   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97895   bool result;
97896
97897   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97898   {
97899     try {
97900       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
97901     } catch (std::out_of_range& e) {
97902       {
97903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97904       };
97905     } catch (std::exception& e) {
97906       {
97907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97908       };
97909     } catch (Dali::DaliException e) {
97910       {
97911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97912       };
97913     } catch (...) {
97914       {
97915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97916       };
97917     }
97918   }
97919
97920   jresult = result;
97921   return jresult;
97922 }
97923
97924
97925 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
97926   unsigned long jresult ;
97927   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97928   std::size_t result;
97929
97930   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97931   {
97932     try {
97933       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
97934     } catch (std::out_of_range& e) {
97935       {
97936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97937       };
97938     } catch (std::exception& e) {
97939       {
97940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97941       };
97942     } catch (Dali::DaliException e) {
97943       {
97944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97945       };
97946     } catch (...) {
97947       {
97948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97949       };
97950     }
97951   }
97952
97953   jresult = (unsigned long)result;
97954   return jresult;
97955 }
97956
97957
97958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
97959   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97960   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
97961
97962   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97963   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
97964   {
97965     try {
97966       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
97967     } catch (std::out_of_range& e) {
97968       {
97969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97970       };
97971     } catch (std::exception& e) {
97972       {
97973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97974       };
97975     } catch (Dali::DaliException e) {
97976       {
97977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97978       };
97979     } catch (...) {
97980       {
97981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97982       };
97983     }
97984   }
97985
97986 }
97987
97988
97989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
97990   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97991   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
97992
97993   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97994   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
97995   {
97996     try {
97997       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
97998     } catch (std::out_of_range& e) {
97999       {
98000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98001       };
98002     } catch (std::exception& e) {
98003       {
98004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98005       };
98006     } catch (Dali::DaliException e) {
98007       {
98008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98009       };
98010     } catch (...) {
98011       {
98012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98013       };
98014     }
98015   }
98016
98017 }
98018
98019
98020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
98021   unsigned int jresult ;
98022   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98023   Dali::Toolkit::Slider arg2 ;
98024   int arg3 ;
98025   Dali::Toolkit::Slider *argp2 ;
98026   bool result;
98027
98028   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98029   argp2 = (Dali::Toolkit::Slider *)jarg2;
98030   if (!argp2) {
98031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98032     return 0;
98033   }
98034   arg2 = *argp2;
98035   arg3 = (int)jarg3;
98036   {
98037     try {
98038       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
98039     } catch (std::out_of_range& e) {
98040       {
98041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98042       };
98043     } catch (std::exception& e) {
98044       {
98045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98046       };
98047     } catch (Dali::DaliException e) {
98048       {
98049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98050       };
98051     } catch (...) {
98052       {
98053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98054       };
98055     }
98056   }
98057
98058   jresult = result;
98059   return jresult;
98060 }
98061
98062
98063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
98064   void * jresult ;
98065   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
98066
98067   {
98068     try {
98069       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
98070     } catch (std::out_of_range& e) {
98071       {
98072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98073       };
98074     } catch (std::exception& e) {
98075       {
98076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98077       };
98078     } catch (Dali::DaliException e) {
98079       {
98080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98081       };
98082     } catch (...) {
98083       {
98084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98085       };
98086     }
98087   }
98088
98089   jresult = (void *)result;
98090   return jresult;
98091 }
98092
98093
98094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
98095   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98096
98097   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98098   {
98099     try {
98100       delete arg1;
98101     } catch (std::out_of_range& e) {
98102       {
98103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98104       };
98105     } catch (std::exception& e) {
98106       {
98107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98108       };
98109     } catch (Dali::DaliException e) {
98110       {
98111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98112       };
98113     } catch (...) {
98114       {
98115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98116       };
98117     }
98118   }
98119
98120 }
98121
98122
98123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
98124   void * jresult ;
98125   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98126
98127   {
98128     try {
98129       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
98130     } catch (std::out_of_range& e) {
98131       {
98132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98133       };
98134     } catch (std::exception& e) {
98135       {
98136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98137       };
98138     } catch (Dali::DaliException e) {
98139       {
98140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98141       };
98142     } catch (...) {
98143       {
98144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98145       };
98146     }
98147   }
98148
98149   jresult = (void *)result;
98150   return jresult;
98151 }
98152
98153
98154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
98155   void * jresult ;
98156   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
98157   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98158
98159   arg1 = (Dali::Toolkit::Ruler *)jarg1;
98160   {
98161     try {
98162       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
98163     } catch (std::out_of_range& e) {
98164       {
98165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98166       };
98167     } catch (std::exception& e) {
98168       {
98169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98170       };
98171     } catch (Dali::DaliException e) {
98172       {
98173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98174       };
98175     } catch (...) {
98176       {
98177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98178       };
98179     }
98180   }
98181
98182   jresult = (void *)result;
98183   return jresult;
98184 }
98185
98186
98187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
98188   void * jresult ;
98189   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
98190   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98191
98192   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98193   if (!arg1) {
98194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
98195     return 0;
98196   }
98197   {
98198     try {
98199       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
98200     } catch (std::out_of_range& e) {
98201       {
98202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98203       };
98204     } catch (std::exception& e) {
98205       {
98206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98207       };
98208     } catch (Dali::DaliException e) {
98209       {
98210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98211       };
98212     } catch (...) {
98213       {
98214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98215       };
98216     }
98217   }
98218
98219   jresult = (void *)result;
98220   return jresult;
98221 }
98222
98223
98224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
98225   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98226
98227   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98228   {
98229     try {
98230       delete arg1;
98231     } catch (std::out_of_range& e) {
98232       {
98233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98234       };
98235     } catch (std::exception& e) {
98236       {
98237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98238       };
98239     } catch (Dali::DaliException e) {
98240       {
98241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98242       };
98243     } catch (...) {
98244       {
98245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98246       };
98247     }
98248   }
98249
98250 }
98251
98252
98253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
98254   void * jresult ;
98255   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98256   Dali::Toolkit::Ruler *result = 0 ;
98257
98258   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98259   {
98260     try {
98261       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
98262     } catch (std::out_of_range& e) {
98263       {
98264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98265       };
98266     } catch (std::exception& e) {
98267       {
98268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98269       };
98270     } catch (Dali::DaliException e) {
98271       {
98272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98273       };
98274     } catch (...) {
98275       {
98276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98277       };
98278     }
98279   }
98280
98281   jresult = (void *)result;
98282   return jresult;
98283 }
98284
98285
98286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
98287   void * jresult ;
98288   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98289   Dali::Toolkit::Ruler *result = 0 ;
98290
98291   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98292   {
98293     try {
98294       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
98295     } catch (std::out_of_range& e) {
98296       {
98297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98298       };
98299     } catch (std::exception& e) {
98300       {
98301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98302       };
98303     } catch (Dali::DaliException e) {
98304       {
98305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98306       };
98307     } catch (...) {
98308       {
98309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98310       };
98311     }
98312   }
98313
98314   jresult = (void *)result;
98315   return jresult;
98316 }
98317
98318
98319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
98320   void * jresult ;
98321   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98322   Dali::Toolkit::Ruler *result = 0 ;
98323
98324   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98325   {
98326     try {
98327       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
98328     } catch (std::out_of_range& e) {
98329       {
98330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98331       };
98332     } catch (std::exception& e) {
98333       {
98334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98335       };
98336     } catch (Dali::DaliException e) {
98337       {
98338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98339       };
98340     } catch (...) {
98341       {
98342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98343       };
98344     }
98345   }
98346
98347   jresult = (void *)result;
98348   return jresult;
98349 }
98350
98351
98352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
98353   void * jresult ;
98354   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98355   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
98356   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98357
98358   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98359   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
98360   if (!arg2) {
98361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
98362     return 0;
98363   }
98364   {
98365     try {
98366       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
98367     } catch (std::out_of_range& e) {
98368       {
98369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98370       };
98371     } catch (std::exception& e) {
98372       {
98373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98374       };
98375     } catch (Dali::DaliException e) {
98376       {
98377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98378       };
98379     } catch (...) {
98380       {
98381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98382       };
98383     }
98384   }
98385
98386   jresult = (void *)result;
98387   return jresult;
98388 }
98389
98390
98391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
98392   void * jresult ;
98393   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98394   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
98395   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98396
98397   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98398   arg2 = (Dali::Toolkit::Ruler *)jarg2;
98399   {
98400     try {
98401       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
98402     } catch (std::out_of_range& e) {
98403       {
98404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98405       };
98406     } catch (std::exception& e) {
98407       {
98408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98409       };
98410     } catch (Dali::DaliException e) {
98411       {
98412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98413       };
98414     } catch (...) {
98415       {
98416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98417       };
98418     }
98419   }
98420
98421   jresult = (void *)result;
98422   return jresult;
98423 }
98424
98425
98426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
98427   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98428
98429   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98430   {
98431     try {
98432       (arg1)->Reset();
98433     } catch (std::out_of_range& e) {
98434       {
98435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98436       };
98437     } catch (std::exception& e) {
98438       {
98439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98440       };
98441     } catch (Dali::DaliException e) {
98442       {
98443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98444       };
98445     } catch (...) {
98446       {
98447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98448       };
98449     }
98450   }
98451
98452 }
98453
98454
98455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
98456   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98457   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
98458
98459   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98460   arg2 = (Dali::Toolkit::Ruler *)jarg2;
98461   {
98462     try {
98463       (arg1)->Reset(arg2);
98464     } catch (std::out_of_range& e) {
98465       {
98466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98467       };
98468     } catch (std::exception& e) {
98469       {
98470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98471       };
98472     } catch (Dali::DaliException e) {
98473       {
98474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98475       };
98476     } catch (...) {
98477       {
98478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98479       };
98480     }
98481   }
98482
98483 }
98484
98485
98486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
98487   void * jresult ;
98488   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98489   Dali::Toolkit::Ruler *result = 0 ;
98490
98491   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98492   {
98493     try {
98494       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
98495     } catch (std::out_of_range& e) {
98496       {
98497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98498       };
98499     } catch (std::exception& e) {
98500       {
98501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98502       };
98503     } catch (Dali::DaliException e) {
98504       {
98505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98506       };
98507     } catch (...) {
98508       {
98509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98510       };
98511     }
98512   }
98513
98514   jresult = (void *)result;
98515   return jresult;
98516 }
98517
98518
98519 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
98520   float jresult ;
98521   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98522   float arg2 ;
98523   float arg3 ;
98524   float result;
98525
98526   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98527   arg2 = (float)jarg2;
98528   arg3 = (float)jarg3;
98529   {
98530     try {
98531       result = (float)(*arg1)->Snap(arg2,arg3);
98532     } catch (std::out_of_range& e) {
98533       {
98534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98535       };
98536     } catch (std::exception& e) {
98537       {
98538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98539       };
98540     } catch (Dali::DaliException e) {
98541       {
98542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98543       };
98544     } catch (...) {
98545       {
98546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98547       };
98548     }
98549   }
98550
98551   jresult = result;
98552   return jresult;
98553 }
98554
98555
98556 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
98557   float jresult ;
98558   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98559   float arg2 ;
98560   float result;
98561
98562   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98563   arg2 = (float)jarg2;
98564   {
98565     try {
98566       result = (float)(*arg1)->Snap(arg2);
98567     } catch (std::out_of_range& e) {
98568       {
98569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98570       };
98571     } catch (std::exception& e) {
98572       {
98573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98574       };
98575     } catch (Dali::DaliException e) {
98576       {
98577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98578       };
98579     } catch (...) {
98580       {
98581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98582       };
98583     }
98584   }
98585
98586   jresult = result;
98587   return jresult;
98588 }
98589
98590
98591 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
98592   float jresult ;
98593   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98594   unsigned int arg2 ;
98595   unsigned int *arg3 = 0 ;
98596   bool arg4 ;
98597   float result;
98598
98599   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98600   arg2 = (unsigned int)jarg2;
98601   arg3 = (unsigned int *)jarg3;
98602   arg4 = jarg4 ? true : false;
98603   {
98604     try {
98605       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
98606     } catch (std::out_of_range& e) {
98607       {
98608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98609       };
98610     } catch (std::exception& e) {
98611       {
98612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98613       };
98614     } catch (Dali::DaliException e) {
98615       {
98616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98617       };
98618     } catch (...) {
98619       {
98620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98621       };
98622     }
98623   }
98624
98625   jresult = result;
98626   return jresult;
98627 }
98628
98629
98630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
98631   unsigned int jresult ;
98632   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98633   float arg2 ;
98634   bool arg3 ;
98635   unsigned int result;
98636
98637   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98638   arg2 = (float)jarg2;
98639   arg3 = jarg3 ? true : false;
98640   {
98641     try {
98642       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
98643     } catch (std::out_of_range& e) {
98644       {
98645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98646       };
98647     } catch (std::exception& e) {
98648       {
98649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98650       };
98651     } catch (Dali::DaliException e) {
98652       {
98653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98654       };
98655     } catch (...) {
98656       {
98657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98658       };
98659     }
98660   }
98661
98662   jresult = result;
98663   return jresult;
98664 }
98665
98666
98667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
98668   unsigned int jresult ;
98669   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98670   unsigned int result;
98671
98672   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98673   {
98674     try {
98675       result = (unsigned int)(*arg1)->GetTotalPages();
98676     } catch (std::out_of_range& e) {
98677       {
98678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98679       };
98680     } catch (std::exception& e) {
98681       {
98682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98683       };
98684     } catch (Dali::DaliException e) {
98685       {
98686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98687       };
98688     } catch (...) {
98689       {
98690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98691       };
98692     }
98693   }
98694
98695   jresult = result;
98696   return jresult;
98697 }
98698
98699
98700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
98701   int jresult ;
98702   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98703   Dali::Toolkit::Ruler::RulerType result;
98704
98705   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98706   {
98707     try {
98708       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
98709     } catch (std::out_of_range& e) {
98710       {
98711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98712       };
98713     } catch (std::exception& e) {
98714       {
98715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98716       };
98717     } catch (Dali::DaliException e) {
98718       {
98719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98720       };
98721     } catch (...) {
98722       {
98723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98724       };
98725     }
98726   }
98727
98728   jresult = (int)result;
98729   return jresult;
98730 }
98731
98732
98733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
98734   unsigned int jresult ;
98735   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98736   bool result;
98737
98738   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98739   {
98740     try {
98741       result = (bool)(*arg1)->IsEnabled();
98742     } catch (std::out_of_range& e) {
98743       {
98744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98745       };
98746     } catch (std::exception& e) {
98747       {
98748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98749       };
98750     } catch (Dali::DaliException e) {
98751       {
98752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98753       };
98754     } catch (...) {
98755       {
98756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98757       };
98758     }
98759   }
98760
98761   jresult = result;
98762   return jresult;
98763 }
98764
98765
98766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
98767   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98768
98769   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98770   {
98771     try {
98772       (*arg1)->Enable();
98773     } catch (std::out_of_range& e) {
98774       {
98775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98776       };
98777     } catch (std::exception& e) {
98778       {
98779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98780       };
98781     } catch (Dali::DaliException e) {
98782       {
98783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98784       };
98785     } catch (...) {
98786       {
98787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98788       };
98789     }
98790   }
98791
98792 }
98793
98794
98795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
98796   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98797
98798   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98799   {
98800     try {
98801       (*arg1)->Disable();
98802     } catch (std::out_of_range& e) {
98803       {
98804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98805       };
98806     } catch (std::exception& e) {
98807       {
98808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98809       };
98810     } catch (Dali::DaliException e) {
98811       {
98812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98813       };
98814     } catch (...) {
98815       {
98816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98817       };
98818     }
98819   }
98820
98821 }
98822
98823
98824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
98825   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98826   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
98827   Dali::Toolkit::RulerDomain *argp2 ;
98828
98829   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98830   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
98831   if (!argp2) {
98832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
98833     return ;
98834   }
98835   arg2 = *argp2;
98836   {
98837     try {
98838       (*arg1)->SetDomain(arg2);
98839     } catch (std::out_of_range& e) {
98840       {
98841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98842       };
98843     } catch (std::exception& e) {
98844       {
98845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98846       };
98847     } catch (Dali::DaliException e) {
98848       {
98849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98850       };
98851     } catch (...) {
98852       {
98853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98854       };
98855     }
98856   }
98857
98858 }
98859
98860
98861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
98862   void * jresult ;
98863   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98864   Dali::Toolkit::RulerDomain *result = 0 ;
98865
98866   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98867   {
98868     try {
98869       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
98870     } catch (std::out_of_range& e) {
98871       {
98872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98873       };
98874     } catch (std::exception& e) {
98875       {
98876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98877       };
98878     } catch (Dali::DaliException e) {
98879       {
98880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98881       };
98882     } catch (...) {
98883       {
98884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98885       };
98886     }
98887   }
98888
98889   jresult = (void *)result;
98890   return jresult;
98891 }
98892
98893
98894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
98895   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98896
98897   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98898   {
98899     try {
98900       (*arg1)->DisableDomain();
98901     } catch (std::out_of_range& e) {
98902       {
98903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98904       };
98905     } catch (std::exception& e) {
98906       {
98907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98908       };
98909     } catch (Dali::DaliException e) {
98910       {
98911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98912       };
98913     } catch (...) {
98914       {
98915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98916       };
98917     }
98918   }
98919
98920 }
98921
98922
98923 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(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)->Clamp(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_Clamp__SWIG_1(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)->Clamp(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_Clamp__SWIG_2(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)->Clamp(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_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
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   Dali::Toolkit::ClampState *arg5 = 0 ;
99041   float result;
99042
99043   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99044   arg2 = (float)jarg2;
99045   arg3 = (float)jarg3;
99046   arg4 = (float)jarg4;
99047   arg5 = (Dali::Toolkit::ClampState *)jarg5;
99048   if (!arg5) {
99049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
99050     return 0;
99051   }
99052   {
99053     try {
99054       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
99055     } catch (std::out_of_range& e) {
99056       {
99057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99058       };
99059     } catch (std::exception& e) {
99060       {
99061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99062       };
99063     } catch (Dali::DaliException e) {
99064       {
99065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99066       };
99067     } catch (...) {
99068       {
99069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99070       };
99071     }
99072   }
99073
99074   jresult = result;
99075   return jresult;
99076 }
99077
99078
99079 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
99080   float jresult ;
99081   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99082   float arg2 ;
99083   float arg3 ;
99084   float arg4 ;
99085   float arg5 ;
99086   float result;
99087
99088   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99089   arg2 = (float)jarg2;
99090   arg3 = (float)jarg3;
99091   arg4 = (float)jarg4;
99092   arg5 = (float)jarg5;
99093   {
99094     try {
99095       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
99096     } catch (std::out_of_range& e) {
99097       {
99098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99099       };
99100     } catch (std::exception& e) {
99101       {
99102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99103       };
99104     } catch (Dali::DaliException e) {
99105       {
99106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99107       };
99108     } catch (...) {
99109       {
99110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99111       };
99112     }
99113   }
99114
99115   jresult = result;
99116   return jresult;
99117 }
99118
99119
99120 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
99121   float jresult ;
99122   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99123   float arg2 ;
99124   float arg3 ;
99125   float arg4 ;
99126   float result;
99127
99128   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99129   arg2 = (float)jarg2;
99130   arg3 = (float)jarg3;
99131   arg4 = (float)jarg4;
99132   {
99133     try {
99134       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
99135     } catch (std::out_of_range& e) {
99136       {
99137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99138       };
99139     } catch (std::exception& e) {
99140       {
99141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99142       };
99143     } catch (Dali::DaliException e) {
99144       {
99145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99146       };
99147     } catch (...) {
99148       {
99149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99150       };
99151     }
99152   }
99153
99154   jresult = result;
99155   return jresult;
99156 }
99157
99158
99159 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
99160   float jresult ;
99161   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99162   float arg2 ;
99163   float arg3 ;
99164   float result;
99165
99166   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99167   arg2 = (float)jarg2;
99168   arg3 = (float)jarg3;
99169   {
99170     try {
99171       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
99172     } catch (std::out_of_range& e) {
99173       {
99174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99175       };
99176     } catch (std::exception& e) {
99177       {
99178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99179       };
99180     } catch (Dali::DaliException e) {
99181       {
99182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99183       };
99184     } catch (...) {
99185       {
99186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99187       };
99188     }
99189   }
99190
99191   jresult = result;
99192   return jresult;
99193 }
99194
99195
99196 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
99197   float jresult ;
99198   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99199   float arg2 ;
99200   float result;
99201
99202   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99203   arg2 = (float)jarg2;
99204   {
99205     try {
99206       result = (float)(*arg1)->SnapAndClamp(arg2);
99207     } catch (std::out_of_range& e) {
99208       {
99209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99210       };
99211     } catch (std::exception& e) {
99212       {
99213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99214       };
99215     } catch (Dali::DaliException e) {
99216       {
99217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99218       };
99219     } catch (...) {
99220       {
99221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99222       };
99223     }
99224   }
99225
99226   jresult = result;
99227   return jresult;
99228 }
99229
99230
99231 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
99232   float jresult ;
99233   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99234   float arg2 ;
99235   float arg3 ;
99236   float arg4 ;
99237   float arg5 ;
99238   Dali::Toolkit::ClampState *arg6 = 0 ;
99239   float result;
99240
99241   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99242   arg2 = (float)jarg2;
99243   arg3 = (float)jarg3;
99244   arg4 = (float)jarg4;
99245   arg5 = (float)jarg5;
99246   arg6 = (Dali::Toolkit::ClampState *)jarg6;
99247   if (!arg6) {
99248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
99249     return 0;
99250   }
99251   {
99252     try {
99253       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
99254     } catch (std::out_of_range& e) {
99255       {
99256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99257       };
99258     } catch (std::exception& e) {
99259       {
99260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99261       };
99262     } catch (Dali::DaliException e) {
99263       {
99264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99265       };
99266     } catch (...) {
99267       {
99268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99269       };
99270     }
99271   }
99272
99273   jresult = result;
99274   return jresult;
99275 }
99276
99277
99278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
99279   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99280
99281   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99282   {
99283     try {
99284       (*arg1)->Reference();
99285     } catch (std::out_of_range& e) {
99286       {
99287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99288       };
99289     } catch (std::exception& e) {
99290       {
99291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99292       };
99293     } catch (Dali::DaliException e) {
99294       {
99295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99296       };
99297     } catch (...) {
99298       {
99299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99300       };
99301     }
99302   }
99303
99304 }
99305
99306
99307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
99308   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99309
99310   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99311   {
99312     try {
99313       (*arg1)->Unreference();
99314     } catch (std::out_of_range& e) {
99315       {
99316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99317       };
99318     } catch (std::exception& e) {
99319       {
99320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99321       };
99322     } catch (Dali::DaliException e) {
99323       {
99324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99325       };
99326     } catch (...) {
99327       {
99328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99329       };
99330     }
99331   }
99332
99333 }
99334
99335
99336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
99337   int jresult ;
99338   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99339   int result;
99340
99341   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99342   {
99343     try {
99344       result = (int)(*arg1)->ReferenceCount();
99345     } catch (std::out_of_range& e) {
99346       {
99347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99348       };
99349     } catch (std::exception& e) {
99350       {
99351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99352       };
99353     } catch (Dali::DaliException e) {
99354       {
99355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99356       };
99357     } catch (...) {
99358       {
99359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99360       };
99361     }
99362   }
99363
99364   jresult = result;
99365   return jresult;
99366 }
99367
99368
99369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
99370   unsigned int jresult ;
99371   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99372   bool result;
99373
99374   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99375   {
99376     try {
99377       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
99378     } catch (std::out_of_range& e) {
99379       {
99380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99381       };
99382     } catch (std::exception& e) {
99383       {
99384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99385       };
99386     } catch (Dali::DaliException e) {
99387       {
99388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99389       };
99390     } catch (...) {
99391       {
99392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99393       };
99394     }
99395   }
99396
99397   jresult = result;
99398   return jresult;
99399 }
99400
99401
99402 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
99403   unsigned long jresult ;
99404   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99405   std::size_t result;
99406
99407   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99408   {
99409     try {
99410       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
99411     } catch (std::out_of_range& e) {
99412       {
99413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99414       };
99415     } catch (std::exception& e) {
99416       {
99417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99418       };
99419     } catch (Dali::DaliException e) {
99420       {
99421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99422       };
99423     } catch (...) {
99424       {
99425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99426       };
99427     }
99428   }
99429
99430   jresult = (unsigned long)result;
99431   return jresult;
99432 }
99433
99434
99435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
99436   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99437   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
99438
99439   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99440   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
99441   {
99442     try {
99443       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
99444     } catch (std::out_of_range& e) {
99445       {
99446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99447       };
99448     } catch (std::exception& e) {
99449       {
99450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99451       };
99452     } catch (Dali::DaliException e) {
99453       {
99454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99455       };
99456     } catch (...) {
99457       {
99458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99459       };
99460     }
99461   }
99462
99463 }
99464
99465
99466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
99467   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99468   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
99469
99470   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99471   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
99472   {
99473     try {
99474       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
99475     } catch (std::out_of_range& e) {
99476       {
99477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99478       };
99479     } catch (std::exception& e) {
99480       {
99481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99482       };
99483     } catch (Dali::DaliException e) {
99484       {
99485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99486       };
99487     } catch (...) {
99488       {
99489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99490       };
99491     }
99492   }
99493
99494 }
99495
99496
99497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
99498   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99499   Dali::Toolkit::Control arg2 ;
99500   Dali::Toolkit::Control *argp2 ;
99501
99502   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99503   argp2 = (Dali::Toolkit::Control *)jarg2;
99504   if (!argp2) {
99505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
99506     return ;
99507   }
99508   arg2 = *argp2;
99509   {
99510     try {
99511       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
99512     } catch (std::out_of_range& e) {
99513       {
99514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99515       };
99516     } catch (std::exception& e) {
99517       {
99518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99519       };
99520     } catch (Dali::DaliException e) {
99521       {
99522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99523       };
99524     } catch (...) {
99525       {
99526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99527       };
99528     }
99529   }
99530
99531 }
99532
99533
99534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
99535   void * jresult ;
99536   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
99537
99538   {
99539     try {
99540       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
99541     } catch (std::out_of_range& e) {
99542       {
99543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99544       };
99545     } catch (std::exception& e) {
99546       {
99547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99548       };
99549     } catch (Dali::DaliException e) {
99550       {
99551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99552       };
99553     } catch (...) {
99554       {
99555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99556       };
99557     }
99558   }
99559
99560   jresult = (void *)result;
99561   return jresult;
99562 }
99563
99564
99565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
99566   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99567
99568   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99569   {
99570     try {
99571       delete arg1;
99572     } catch (std::out_of_range& e) {
99573       {
99574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99575       };
99576     } catch (std::exception& e) {
99577       {
99578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99579       };
99580     } catch (Dali::DaliException e) {
99581       {
99582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99583       };
99584     } catch (...) {
99585       {
99586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99587       };
99588     }
99589   }
99590
99591 }
99592
99593 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
99594   Dali::RefObject *result = NULL;
99595
99596   if (arg1)
99597   {
99598     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
99599   }
99600   return result;
99601 }
99602
99603 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
99604     return (Dali::RefObject *)jarg1;
99605 }
99606
99607 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
99608     return (Dali::SignalObserver *)jarg1;
99609 }
99610
99611 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
99612     return (Dali::ConnectionTrackerInterface *)jarg1;
99613 }
99614
99615 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
99616     return (Dali::BaseHandle *)jarg1;
99617 }
99618
99619 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
99620     return (Dali::BaseHandle *)jarg1;
99621 }
99622
99623 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
99624     return (Dali::BaseHandle *)jarg1;
99625 }
99626
99627 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
99628     return (Dali::BaseHandle *)jarg1;
99629 }
99630
99631 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
99632     return (Dali::BaseHandle *)jarg1;
99633 }
99634
99635 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
99636     return (Dali::BaseHandle *)jarg1;
99637 }
99638
99639 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
99640     return (Dali::BaseHandle *)jarg1;
99641 }
99642
99643 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
99644     return (Dali::BaseHandle *)jarg1;
99645 }
99646
99647 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
99648     return (Dali::BaseHandle *)jarg1;
99649 }
99650
99651 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
99652     return (Dali::BaseHandle *)jarg1;
99653 }
99654
99655 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
99656     return (Dali::BaseHandle *)jarg1;
99657 }
99658
99659 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
99660     return (Dali::BaseHandle *)jarg1;
99661 }
99662
99663 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
99664     return (Dali::BaseHandle *)jarg1;
99665 }
99666
99667 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
99668     return (Dali::Handle *)jarg1;
99669 }
99670
99671 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
99672     return (Dali::Handle *)jarg1;
99673 }
99674
99675 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
99676     return (Dali::BaseHandle *)jarg1;
99677 }
99678
99679 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
99680     return (Dali::BaseHandle *)jarg1;
99681 }
99682
99683 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
99684     return (Dali::Handle *)jarg1;
99685 }
99686
99687 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
99688     return (Dali::BaseHandle *)jarg1;
99689 }
99690
99691 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
99692     return (Dali::Handle *)jarg1;
99693 }
99694
99695 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
99696     return (Dali::GestureDetector *)jarg1;
99697 }
99698
99699 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
99700     return (Dali::Gesture *)jarg1;
99701 }
99702
99703 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
99704     return (Dali::Handle *)jarg1;
99705 }
99706
99707 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
99708     return (Dali::Actor *)jarg1;
99709 }
99710
99711 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
99712     return (Dali::BaseHandle *)jarg1;
99713 }
99714
99715 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
99716     return (Dali::RefObject *)jarg1;
99717 }
99718
99719 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
99720     return (Dali::Actor *)jarg1;
99721 }
99722
99723 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
99724     return (Dali::GestureDetector *)jarg1;
99725 }
99726
99727 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
99728     return (Dali::Gesture *)jarg1;
99729 }
99730
99731 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
99732     return (Dali::GestureDetector *)jarg1;
99733 }
99734
99735 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
99736     return (Dali::Gesture *)jarg1;
99737 }
99738
99739 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
99740     return (Dali::GestureDetector *)jarg1;
99741 }
99742
99743 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
99744     return (Dali::Gesture *)jarg1;
99745 }
99746
99747 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
99748     return (Dali::BaseHandle *)jarg1;
99749 }
99750
99751 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
99752     return (Dali::Handle *)jarg1;
99753 }
99754
99755 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
99756     return (Dali::Handle *)jarg1;
99757 }
99758
99759 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
99760     return (Dali::Handle *)jarg1;
99761 }
99762
99763 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
99764     return (Dali::Image *)jarg1;
99765 }
99766
99767 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
99768     return (Dali::Image *)jarg1;
99769 }
99770
99771 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
99772     return (Dali::Image *)jarg1;
99773 }
99774
99775 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
99776     return (Dali::RefObject *)jarg1;
99777 }
99778
99779 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
99780     return (Dali::Image *)jarg1;
99781 }
99782
99783 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
99784     return (Dali::Image *)jarg1;
99785 }
99786
99787 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
99788     return (Dali::ResourceImage *)jarg1;
99789 }
99790
99791 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
99792     return (Dali::Actor *)jarg1;
99793 }
99794
99795 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
99796     return (Dali::BaseHandle *)jarg1;
99797 }
99798
99799 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
99800     return (Dali::BaseHandle *)jarg1;
99801 }
99802
99803 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
99804     return (Dali::BaseHandle *)jarg1;
99805 }
99806
99807 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
99808     return (Dali::CustomActorImpl *)jarg1;
99809 }
99810
99811 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
99812     return (Dali::CustomActor *)jarg1;
99813 }
99814
99815 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
99816     return (Dali::BaseHandle *)jarg1;
99817 }
99818
99819 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
99820     return (Dali::Toolkit::Control *)jarg1;
99821 }
99822
99823 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
99824     return (Dali::Toolkit::Control *)jarg1;
99825 }
99826
99827 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
99828     return (Dali::Toolkit::Button *)jarg1;
99829 }
99830
99831 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
99832     return (Dali::Toolkit::Button *)jarg1;
99833 }
99834
99835 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
99836     return (Dali::Toolkit::Button *)jarg1;
99837 }
99838
99839 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
99840     return (Dali::Toolkit::Control *)jarg1;
99841 }
99842
99843 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
99844     return (Dali::Toolkit::Control *)jarg1;
99845 }
99846
99847 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
99848     return (Dali::Toolkit::Control *)jarg1;
99849 }
99850
99851 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
99852     return (Dali::Toolkit::Control *)jarg1;
99853 }
99854
99855 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
99856     return (Dali::Toolkit::Control *)jarg1;
99857 }
99858
99859 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
99860     return (Dali::RefObject *)jarg1;
99861 }
99862
99863 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
99864     return (Dali::Toolkit::Scrollable *)jarg1;
99865 }
99866
99867 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
99868     return (Dali::BaseHandle *)jarg1;
99869 }
99870
99871 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
99872     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
99873 }
99874
99875 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
99876     return (Dali::RefObject *)jarg1;
99877 }
99878
99879 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
99880     return (Dali::Toolkit::Ruler *)jarg1;
99881 }
99882
99883 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
99884     return (Dali::Toolkit::Ruler *)jarg1;
99885 }
99886
99887 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
99888     return (Dali::Toolkit::Scrollable *)jarg1;
99889 }
99890
99891 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
99892     return (Dali::Toolkit::Control *)jarg1;
99893 }
99894
99895
99896 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
99897     return (Dali::Toolkit::Control *)jarg1;
99898 }
99899
99900 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
99901     return (Dali::BaseHandle *)jarg1;
99902 }
99903
99904 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
99905     return (Dali::BaseHandle *)jarg1;
99906 }
99907
99908 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
99909     return (Dali::Toolkit::Control *)jarg1;
99910 }
99911
99912 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
99913     return (Dali::Toolkit::Control *)jarg1;
99914 }
99915
99916 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
99917     return (Dali::Toolkit::Control *)jarg1;
99918 }
99919
99920 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
99921     return (Dali::Toolkit::Control *)jarg1;
99922 }
99923
99924 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
99925     return (Dali::Toolkit::Control *)jarg1;
99926 }
99927
99928 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
99929     return (Dali::Toolkit::Control *)jarg1;
99930 }
99931
99932 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
99933     return (Dali::Toolkit::PageTurnView *)jarg1;
99934 }
99935
99936 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
99937     return (Dali::Toolkit::PageTurnView *)jarg1;
99938 }
99939
99940 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
99941     return (Dali::Toolkit::Button *)jarg1;
99942 }
99943
99944 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
99945     return (Dali::BaseHandle *)jarg1;
99946 }
99947
99948 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
99949     return (Dali::BaseHandle *)jarg1;
99950 }
99951
99952 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
99953     return (Dali::BaseHandle *)jarg1;
99954 }
99955
99956 /*
99957  * Widget binding
99958  */
99959 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
99960     return (Dali::BaseHandle *)jarg1;
99961 }
99962
99963 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
99964     return (Dali::BaseObject *)jarg1;
99965 }
99966
99967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
99968   void * jresult ;
99969   Dali::Widget result;
99970
99971   {
99972     try {
99973       result = Dali::Widget::New();
99974     } catch (std::out_of_range& e) {
99975       {
99976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99977       };
99978     } catch (std::exception& e) {
99979       {
99980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99981       };
99982     } catch (...) {
99983       {
99984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99985       };
99986     }
99987   }
99988   jresult = new Dali::Widget((const Dali::Widget &)result);
99989   return jresult;
99990 }
99991
99992
99993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
99994   void * jresult ;
99995   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
99996   Dali::Widget result;
99997
99998   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99999
100000   if (!arg1) {
100001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
100002     return 0;
100003   }
100004   {
100005     try {
100006       jresult = new Dali::Widget(arg1);
100007     } catch (std::out_of_range& e) {
100008       {
100009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100010       };
100011     } catch (std::exception& e) {
100012       {
100013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100014       };
100015     } catch (...) {
100016       {
100017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100018       };
100019     }
100020   }
100021   return jresult;
100022 }
100023
100024
100025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
100026   void * jresult ;
100027   Dali::Widget *result = 0 ;
100028
100029   {
100030     try {
100031       result = (Dali::Widget *)new Dali::Widget();
100032     } catch (std::out_of_range& e) {
100033       {
100034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100035       };
100036     } catch (std::exception& e) {
100037       {
100038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100039       };
100040     } catch (...) {
100041       {
100042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100043       };
100044     }
100045   }
100046   jresult = (void *)result;
100047   return jresult;
100048 }
100049
100050
100051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
100052   void * jresult ;
100053   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
100054   Dali::Widget *arg2 = 0 ;
100055   Dali::Widget *result = 0 ;
100056
100057   arg1 = (Dali::Widget *)jarg1;
100058   arg2 = (Dali::Widget *)jarg2;
100059   if (!arg2) {
100060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
100061     return 0;
100062   }
100063   {
100064     try {
100065       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
100066     } catch (std::out_of_range& e) {
100067       {
100068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100069       };
100070     } catch (std::exception& e) {
100071       {
100072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100073       };
100074     } catch (...) {
100075       {
100076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100077       };
100078     }
100079   }
100080   jresult = (void *)result;
100081   return jresult;
100082 }
100083
100084
100085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
100086   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
100087
100088   arg1 = (Dali::Widget *)jarg1;
100089   {
100090     try {
100091       delete arg1;
100092     } catch (std::out_of_range& e) {
100093       {
100094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100095       };
100096     } catch (std::exception& e) {
100097       {
100098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100099       };
100100     } catch (...) {
100101       {
100102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100103       };
100104     }
100105   }
100106 }
100107
100108
100109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
100110   void * jresult ;
100111   SwigDirector_WidgetImpl* result;
100112   {
100113     try {
100114       result = new SwigDirector_WidgetImpl();
100115     } catch (std::out_of_range& e) {
100116       {
100117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100118       };
100119     } catch (std::exception& e) {
100120       {
100121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100122       };
100123     } catch (...) {
100124       {
100125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100126       };
100127     }
100128   }
100129   jresult = result;
100130   return jresult;
100131 }
100132
100133
100134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
100135   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100136   std::string *arg2 = 0 ;
100137   Dali::Window arg3 ;
100138   Dali::Window *argp3 ;
100139
100140   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100141   if (!jarg2) {
100142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100143     return ;
100144   }
100145   std::string arg2_str(jarg2);
100146   arg2 = &arg2_str;
100147   argp3 = (Dali::Window *)jarg3;
100148   if (!argp3) {
100149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100150     return ;
100151   }
100152   arg3 = *argp3;
100153   {
100154     try {
100155       (arg1)->OnCreate((std::string const &)*arg2,arg3);
100156     } catch (std::out_of_range& e) {
100157       {
100158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100159       };
100160     } catch (std::exception& e) {
100161       {
100162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100163       };
100164     } catch (...) {
100165       {
100166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100167       };
100168     }
100169   }
100170 }
100171
100172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
100173   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100174   std::string *arg2 = 0 ;
100175   Dali::Window arg3 ;
100176   Dali::Window *argp3 ;
100177
100178   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100179   if (!jarg2) {
100180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100181     return ;
100182   }
100183   std::string arg2_str(jarg2);
100184   arg2 = &arg2_str;
100185   argp3 = (Dali::Window *)jarg3;
100186   if (!argp3) {
100187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100188     return ;
100189   }
100190   arg3 = *argp3;
100191   {
100192     try {
100193       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
100194     } catch (std::out_of_range& e) {
100195       {
100196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100197       };
100198     } catch (std::exception& e) {
100199       {
100200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100201       };
100202     } catch (...) {
100203       {
100204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100205       };
100206     }
100207   }
100208 }
100209
100210
100211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
100212   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100213   std::string *arg2 = 0 ;
100214   Dali::Widget::Termination arg3 ;
100215
100216   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100217   if (!jarg2) {
100218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100219     return ;
100220   }
100221   std::string arg2_str(jarg2);
100222   arg2 = &arg2_str;
100223   arg3 = (Dali::Widget::Termination)jarg3;
100224   {
100225     try {
100226       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
100227     } catch (std::out_of_range& e) {
100228       {
100229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100230       };
100231     } catch (std::exception& e) {
100232       {
100233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100234       };
100235     } catch (...) {
100236       {
100237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100238       };
100239     }
100240   }
100241 }
100242
100243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
100244   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100245   std::string *arg2 = 0 ;
100246   Dali::Widget::Termination arg3 ;
100247
100248   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100249   if (!jarg2) {
100250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100251     return ;
100252   }
100253   std::string arg2_str(jarg2);
100254   arg2 = &arg2_str;
100255   arg3 = (Dali::Widget::Termination)jarg3;
100256   {
100257     try {
100258       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
100259     } catch (std::out_of_range& e) {
100260       {
100261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100262       };
100263     } catch (std::exception& e) {
100264       {
100265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100266       };
100267     } catch (...) {
100268       {
100269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100270       };
100271     }
100272   }
100273 }
100274
100275
100276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
100277   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100278
100279   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100280   {
100281     try {
100282       (arg1)->OnPause();
100283     } catch (std::out_of_range& e) {
100284       {
100285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100286       };
100287     } catch (std::exception& e) {
100288       {
100289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100290       };
100291     } catch (...) {
100292       {
100293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100294       };
100295     }
100296   }
100297 }
100298
100299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
100300   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100301
100302   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100303   {
100304     try {
100305       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
100306     } catch (std::out_of_range& e) {
100307       {
100308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100309       };
100310     } catch (std::exception& e) {
100311       {
100312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100313       };
100314     } catch (...) {
100315       {
100316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100317       };
100318     }
100319   }
100320 }
100321
100322
100323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
100324   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100325
100326   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100327   {
100328     try {
100329       (arg1)->OnResume();
100330     } catch (std::out_of_range& e) {
100331       {
100332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100333       };
100334     } catch (std::exception& e) {
100335       {
100336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100337       };
100338     } catch (...) {
100339       {
100340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100341       };
100342     }
100343   }
100344 }
100345
100346
100347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
100348   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100349
100350   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100351   {
100352     try {
100353       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
100354     } catch (std::out_of_range& e) {
100355       {
100356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100357       };
100358     } catch (std::exception& e) {
100359       {
100360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100361       };
100362     } catch (...) {
100363       {
100364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100365       };
100366     }
100367   }
100368 }
100369
100370
100371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
100372   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100373   Dali::Window arg2 ;
100374   Dali::Window *argp2 ;
100375
100376   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100377   argp2 = (Dali::Window *)jarg2;
100378   if (!argp2) {
100379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100380     return ;
100381   }
100382   arg2 = *argp2;
100383   {
100384     try {
100385       (arg1)->OnResize(arg2);
100386     } catch (std::out_of_range& e) {
100387       {
100388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100389       };
100390     } catch (std::exception& e) {
100391       {
100392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100393       };
100394     } catch (...) {
100395       {
100396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100397       };
100398     }
100399   }
100400 }
100401
100402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
100403   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100404   Dali::Window arg2 ;
100405   Dali::Window *argp2 ;
100406
100407   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100408   argp2 = (Dali::Window *)jarg2;
100409   if (!argp2) {
100410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100411     return ;
100412   }
100413   arg2 = *argp2;
100414   {
100415     try {
100416       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
100417     } catch (std::out_of_range& e) {
100418       {
100419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100420       };
100421     } catch (std::exception& e) {
100422       {
100423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100424       };
100425     } catch (...) {
100426       {
100427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100428       };
100429     }
100430   }
100431 }
100432
100433
100434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
100435   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100436   std::string *arg2 = 0 ;
100437   int arg3 ;
100438
100439   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100440   if (!jarg2) {
100441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100442     return ;
100443   }
100444   std::string arg2_str(jarg2);
100445   arg2 = &arg2_str;
100446   arg3 = (int)jarg3;
100447   {
100448     try {
100449       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
100450     } catch (std::out_of_range& e) {
100451       {
100452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100453       };
100454     } catch (std::exception& e) {
100455       {
100456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100457       };
100458     } catch (...) {
100459       {
100460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100461       };
100462     }
100463   }
100464 }
100465
100466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
100467   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100468   std::string *arg2 = 0 ;
100469   int arg3 ;
100470
100471   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100472   if (!jarg2) {
100473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100474     return ;
100475   }
100476   std::string arg2_str(jarg2);
100477   arg2 = &arg2_str;
100478   arg3 = (int)jarg3;
100479   {
100480     try {
100481       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
100482     } catch (std::out_of_range& e) {
100483       {
100484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100485       };
100486     } catch (std::exception& e) {
100487       {
100488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100489       };
100490     } catch (...) {
100491       {
100492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100493       };
100494     }
100495   }
100496 }
100497
100498
100499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
100500   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100501   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100502   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100503
100504   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100505   arg2 = (Dali::SlotObserver *)jarg2;
100506   arg3 = (Dali::CallbackBase *)jarg3;
100507   {
100508     try {
100509       (arg1)->SignalConnected(arg2,arg3);
100510     } catch (std::out_of_range& e) {
100511       {
100512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100513       };
100514     } catch (std::exception& e) {
100515       {
100516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100517       };
100518     } catch (...) {
100519       {
100520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100521       };
100522     }
100523   }
100524 }
100525
100526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
100527   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100528   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100529   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100530
100531   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100532   arg2 = (Dali::SlotObserver *)jarg2;
100533   arg3 = (Dali::CallbackBase *)jarg3;
100534   {
100535     try {
100536       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
100537     } catch (std::out_of_range& e) {
100538       {
100539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100540       };
100541     } catch (std::exception& e) {
100542       {
100543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100544       };
100545     } catch (...) {
100546       {
100547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100548       };
100549     }
100550   }
100551 }
100552
100553
100554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
100555   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100556   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100557   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100558
100559   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100560   arg2 = (Dali::SlotObserver *)jarg2;
100561   arg3 = (Dali::CallbackBase *)jarg3;
100562   {
100563     try {
100564       (arg1)->SignalDisconnected(arg2,arg3);
100565     } catch (std::out_of_range& e) {
100566       {
100567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100568       };
100569     } catch (std::exception& e) {
100570       {
100571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100572       };
100573     } catch (...) {
100574       {
100575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100576       };
100577     }
100578   }
100579 }
100580
100581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
100582   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100583   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100584   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100585
100586   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100587   arg2 = (Dali::SlotObserver *)jarg2;
100588   arg3 = (Dali::CallbackBase *)jarg3;
100589   {
100590     try {
100591       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
100592     } catch (std::out_of_range& e) {
100593       {
100594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100595       };
100596     } catch (std::exception& e) {
100597       {
100598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100599       };
100600     } catch (...) {
100601       {
100602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100603       };
100604     }
100605   }
100606 }
100607
100608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
100609   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100610   std::string *arg2 = 0 ;
100611
100612   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100613   if (!jarg2) {
100614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100615     return ;
100616   }
100617   std::string arg2_str(jarg2);
100618   arg2 = &arg2_str;
100619   {
100620     try {
100621       (arg1)->SetContentInfo((std::string const &)*arg2);
100622     } catch (std::out_of_range& e) {
100623       {
100624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100625       };
100626     } catch (std::exception& e) {
100627       {
100628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100629       };
100630     } catch (...) {
100631       {
100632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100633       };
100634     }
100635   }
100636 }
100637
100638
100639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
100640   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100641   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
100642
100643   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100644   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
100645   {
100646     try {
100647       (arg1)->SetImpl(arg2);
100648     } catch (std::out_of_range& e) {
100649       {
100650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100651       };
100652     } catch (std::exception& e) {
100653       {
100654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100655       };
100656     } catch (...) {
100657       {
100658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100659       };
100660     }
100661   }
100662 }
100663
100664 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) {
100665
100666   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
100667   if (director) {
100668     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
100669   }
100670 }
100671
100672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
100673   void * jresult ;
100674   Dali::Widget *arg1 = 0 ;
100675   SwigDirector_WidgetImpl *result = 0 ;
100676
100677   arg1 = (Dali::Widget *)jarg1;
100678   if (!arg1) {
100679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
100680     return 0;
100681   }
100682   {
100683     try {
100684       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
100685     } catch (std::out_of_range& e) {
100686       {
100687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100688       };
100689     } catch (std::exception& e) {
100690       {
100691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100692       };
100693     } catch (...) {
100694       {
100695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100696       };
100697     }
100698   }
100699
100700   jresult = (void *)result;
100701   return jresult;
100702 }
100703
100704
100705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
100706   void * jresult ;
100707   int *arg1 = (int *) 0 ;
100708   char ***arg2 ;
100709   std::string *arg3 = 0 ;
100710   Dali::WidgetApplication result;
100711   {
100712     int index = 0;
100713     int length = 0;
100714     char *retPtr;
100715     char *nextPtr;
100716     argWidgetC = jarg1;
100717     argWidgetV = new char*[jarg1 + 1];
100718
100719     retPtr = strtok_r( jarg2, " ", &nextPtr);
100720     if( retPtr )
100721     {
100722       length = strlen(retPtr);
100723     }
100724     argWidgetV[index] = new char[length + 1];
100725     if( retPtr )
100726     {
100727       strncpy(argWidgetV[index], retPtr, length);
100728     }
100729     argWidgetV[index][length] = '\0';
100730     index++;
100731
100732     while (index < jarg1)
100733     {
100734       length = 0;
100735       retPtr = strtok_r(NULL, " ", &nextPtr);
100736       if( retPtr )
100737       {
100738         length = strlen(retPtr);
100739       }
100740       argWidgetV[index] = new char[length + 1];
100741       if( retPtr )
100742       {
100743         strncpy(argWidgetV[index], retPtr, length);
100744       }
100745       argWidgetV[index][length] = '\0';
100746       index++;
100747     }
100748
100749     argWidgetV[jarg1] = NULL;
100750     argWidgetC = jarg1;
100751
100752     arg1 = &argWidgetC;
100753     arg2 = &argWidgetV;
100754   }
100755
100756   if (!jarg3) {
100757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100758     return 0;
100759   }
100760   std::string arg3_str(jarg3);
100761   arg3 = &arg3_str;
100762   {
100763     try {
100764       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
100765     } catch (std::out_of_range& e) {
100766       {
100767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100768       };
100769     } catch (std::exception& e) {
100770       {
100771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100772       };
100773     } catch (...) {
100774       {
100775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100776       };
100777     }
100778   }
100779   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
100780
100781   return jresult;
100782 }
100783
100784
100785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
100786   void * jresult ;
100787   Dali::WidgetApplication *result = 0 ;
100788
100789   {
100790     try {
100791       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
100792     } catch (std::out_of_range& e) {
100793       {
100794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100795       };
100796     } catch (std::exception& e) {
100797       {
100798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100799       };
100800     } catch (...) {
100801       {
100802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100803       };
100804     }
100805   }
100806   jresult = (void *)result;
100807   return jresult;
100808 }
100809
100810
100811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
100812   void * jresult ;
100813   Dali::WidgetApplication *arg1 = 0 ;
100814   Dali::WidgetApplication *result = 0 ;
100815
100816   arg1 = (Dali::WidgetApplication *)jarg1;
100817   if (!arg1) {
100818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
100819     return 0;
100820   }
100821   {
100822     try {
100823       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
100824     } catch (std::out_of_range& e) {
100825       {
100826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100827       };
100828     } catch (std::exception& e) {
100829       {
100830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100831       };
100832     } catch (...) {
100833       {
100834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100835       };
100836     }
100837   }
100838   jresult = (void *)result;
100839   return jresult;
100840 }
100841
100842
100843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
100844   void * jresult ;
100845   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100846   Dali::WidgetApplication *arg2 = 0 ;
100847   Dali::WidgetApplication *result = 0 ;
100848
100849   arg1 = (Dali::WidgetApplication *)jarg1;
100850   arg2 = (Dali::WidgetApplication *)jarg2;
100851   if (!arg2) {
100852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
100853     return 0;
100854   }
100855   {
100856     try {
100857       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
100858     } catch (std::out_of_range& e) {
100859       {
100860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100861       };
100862     } catch (std::exception& e) {
100863       {
100864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100865       };
100866     } catch (...) {
100867       {
100868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100869       };
100870     }
100871   }
100872   jresult = (void *)result;
100873   return jresult;
100874 }
100875
100876
100877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
100878   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100879
100880   arg1 = (Dali::WidgetApplication *)jarg1;
100881   {
100882     try {
100883       delete arg1;
100884       if( argWidgetV )
100885       {
100886         // free string data
100887         for( int i=0; i < argWidgetC+1; i++)
100888         {
100889           delete [] argWidgetV[i];
100890         }
100891         delete [] argWidgetV;
100892       }
100893     } catch (std::out_of_range& e) {
100894       {
100895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100896       };
100897     } catch (std::exception& e) {
100898       {
100899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100900       };
100901     } catch (...) {
100902       {
100903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100904       };
100905     }
100906   }
100907 }
100908
100909
100910 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
100911 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
100912
100913 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
100914 {
100915   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
100916   return *widget;
100917 }
100918
100919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
100920   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100921   std::string *arg2 = 0 ;
100922
100923   arg1 = (Dali::WidgetApplication *)jarg1;
100924   if (!jarg2) {
100925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100926     return ;
100927   }
100928   std::string arg2_str(*jarg2);
100929   arg2 = &arg2_str;
100930
100931   if(!_CSharpCreateWidgetFunction)
100932   {
100933     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
100934   }
100935
100936   {
100937     try {
100938       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
100939     } catch (std::out_of_range& e) {
100940       {
100941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100942       };
100943     } catch (std::exception& e) {
100944       {
100945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100946       };
100947     } catch (...) {
100948       {
100949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100950       };
100951     }
100952   }
100953
100954   //Typemap argout in c++ file.
100955   //This will convert c++ string to c# string
100956   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
100957 }
100958
100959
100960 //for PixelBuffer and ImageLoading
100961
100962 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
100963     return (Dali::BaseHandle *)jarg1;
100964 }
100965
100966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
100967   void * jresult ;
100968   unsigned int arg1 ;
100969   unsigned int arg2 ;
100970   Dali::Pixel::Format arg3 ;
100971   Dali::Devel::PixelBuffer result;
100972
100973   arg1 = (unsigned int)jarg1;
100974   arg2 = (unsigned int)jarg2;
100975   arg3 = (Dali::Pixel::Format)jarg3;
100976   {
100977     try {
100978       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
100979     } catch (std::out_of_range& e) {
100980       {
100981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100982       };
100983     } catch (std::exception& e) {
100984       {
100985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100986       };
100987     } catch (...) {
100988       {
100989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100990       };
100991     }
100992   }
100993   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
100994   return jresult;
100995 }
100996
100997
100998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
100999   void * jresult ;
101000   Dali::Devel::PixelBuffer *result = 0 ;
101001
101002   {
101003     try {
101004       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
101005     } catch (std::out_of_range& e) {
101006       {
101007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101008       };
101009     } catch (std::exception& e) {
101010       {
101011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101012       };
101013     } catch (...) {
101014       {
101015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101016       };
101017     }
101018   }
101019   jresult = (void *)result;
101020   return jresult;
101021 }
101022
101023
101024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
101025   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101026
101027   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101028   {
101029     try {
101030       delete arg1;
101031     } catch (std::out_of_range& e) {
101032       {
101033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101034       };
101035     } catch (std::exception& e) {
101036       {
101037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101038       };
101039     } catch (...) {
101040       {
101041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101042       };
101043     }
101044   }
101045 }
101046
101047
101048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
101049   void * jresult ;
101050   Dali::Devel::PixelBuffer *arg1 = 0 ;
101051   Dali::Devel::PixelBuffer *result = 0 ;
101052
101053   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101054   if (!arg1) {
101055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101056     return 0;
101057   }
101058   {
101059     try {
101060       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
101061     } catch (std::out_of_range& e) {
101062       {
101063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101064       };
101065     } catch (std::exception& e) {
101066       {
101067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101068       };
101069     } catch (...) {
101070       {
101071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101072       };
101073     }
101074   }
101075   jresult = (void *)result;
101076   return jresult;
101077 }
101078
101079
101080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
101081   void * jresult ;
101082   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101083   Dali::Devel::PixelBuffer *arg2 = 0 ;
101084   Dali::Devel::PixelBuffer *result = 0 ;
101085
101086   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101087   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
101088   if (!arg2) {
101089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101090     return 0;
101091   }
101092   {
101093     try {
101094       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
101095     } catch (std::out_of_range& e) {
101096       {
101097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101098       };
101099     } catch (std::exception& e) {
101100       {
101101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101102       };
101103     } catch (...) {
101104       {
101105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101106       };
101107     }
101108   }
101109   jresult = (void *)result;
101110   return jresult;
101111 }
101112
101113
101114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
101115   void * jresult ;
101116   Dali::Devel::PixelBuffer *arg1 = 0 ;
101117   Dali::PixelData result;
101118
101119   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101120   if (!arg1) {
101121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
101122     return 0;
101123   }
101124   {
101125     try {
101126       result = Dali::Devel::PixelBuffer::Convert(*arg1);
101127     } catch (std::out_of_range& e) {
101128       {
101129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101130       };
101131     } catch (std::exception& e) {
101132       {
101133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101134       };
101135     } catch (...) {
101136       {
101137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101138       };
101139     }
101140   }
101141   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101142   return jresult;
101143 }
101144
101145
101146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
101147   void * jresult ;
101148   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101149   Dali::PixelData result;
101150
101151   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101152   {
101153     try {
101154       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
101155     } catch (std::out_of_range& e) {
101156       {
101157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101158       };
101159     } catch (std::exception& e) {
101160       {
101161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101162       };
101163     } catch (...) {
101164       {
101165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101166       };
101167     }
101168   }
101169   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101170   return jresult;
101171 }
101172
101173
101174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
101175   void * jresult ;
101176   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101177   unsigned char *result = 0 ;
101178
101179   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101180   {
101181     try {
101182       result = (unsigned char *)(arg1)->GetBuffer();
101183     } catch (std::out_of_range& e) {
101184       {
101185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101186       };
101187     } catch (std::exception& e) {
101188       {
101189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101190       };
101191     } catch (...) {
101192       {
101193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101194       };
101195     }
101196   }
101197   jresult = (void *)result;
101198   return jresult;
101199 }
101200
101201
101202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
101203   unsigned int jresult ;
101204   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101205   unsigned int result;
101206
101207   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101208   {
101209     try {
101210       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
101211     } catch (std::out_of_range& e) {
101212       {
101213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101214       };
101215     } catch (std::exception& e) {
101216       {
101217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101218       };
101219     } catch (...) {
101220       {
101221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101222       };
101223     }
101224   }
101225   jresult = result;
101226   return jresult;
101227 }
101228
101229
101230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
101231   unsigned int jresult ;
101232   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101233   unsigned int result;
101234
101235   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101236   {
101237     try {
101238       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
101239     } catch (std::out_of_range& e) {
101240       {
101241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101242       };
101243     } catch (std::exception& e) {
101244       {
101245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101246       };
101247     } catch (...) {
101248       {
101249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101250       };
101251     }
101252   }
101253   jresult = result;
101254   return jresult;
101255 }
101256
101257
101258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
101259   int jresult ;
101260   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101261   Dali::Pixel::Format result;
101262
101263   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101264   {
101265     try {
101266       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
101267     } catch (std::out_of_range& e) {
101268       {
101269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101270       };
101271     } catch (std::exception& e) {
101272       {
101273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101274       };
101275     } catch (...) {
101276       {
101277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101278       };
101279     }
101280   }
101281   jresult = (int)result;
101282   return jresult;
101283 }
101284
101285
101286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
101287   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101288   Dali::Devel::PixelBuffer arg2 ;
101289   float arg3 ;
101290   bool arg4 ;
101291   Dali::Devel::PixelBuffer *argp2 ;
101292
101293   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101294   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101295   if (!argp2) {
101296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101297     return ;
101298   }
101299   arg2 = *argp2;
101300   arg3 = (float)jarg3;
101301   arg4 = jarg4 ? true : false;
101302   {
101303     try {
101304       (arg1)->ApplyMask(arg2,arg3,arg4);
101305     } catch (std::out_of_range& e) {
101306       {
101307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101308       };
101309     } catch (std::exception& e) {
101310       {
101311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101312       };
101313     } catch (...) {
101314       {
101315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101316       };
101317     }
101318   }
101319 }
101320
101321
101322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
101323   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101324   Dali::Devel::PixelBuffer arg2 ;
101325   float arg3 ;
101326   Dali::Devel::PixelBuffer *argp2 ;
101327
101328   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101329   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101330   if (!argp2) {
101331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101332     return ;
101333   }
101334   arg2 = *argp2;
101335   arg3 = (float)jarg3;
101336   {
101337     try {
101338       (arg1)->ApplyMask(arg2,arg3);
101339     } catch (std::out_of_range& e) {
101340       {
101341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101342       };
101343     } catch (std::exception& e) {
101344       {
101345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101346       };
101347     } catch (...) {
101348       {
101349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101350       };
101351     }
101352   }
101353 }
101354
101355
101356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
101357   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101358   Dali::Devel::PixelBuffer arg2 ;
101359   Dali::Devel::PixelBuffer *argp2 ;
101360
101361   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101362   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101363   if (!argp2) {
101364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101365     return ;
101366   }
101367   arg2 = *argp2;
101368   {
101369     try {
101370       (arg1)->ApplyMask(arg2);
101371     } catch (std::out_of_range& e) {
101372       {
101373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101374       };
101375     } catch (std::exception& e) {
101376       {
101377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101378       };
101379     } catch (...) {
101380       {
101381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101382       };
101383     }
101384   }
101385 }
101386
101387
101388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
101389   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101390   float arg2 ;
101391
101392   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101393   arg2 = (float)jarg2;
101394   {
101395     try {
101396       (arg1)->ApplyGaussianBlur(arg2);
101397     } catch (std::out_of_range& e) {
101398       {
101399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101400       };
101401     } catch (std::exception& e) {
101402       {
101403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101404       };
101405     } catch (...) {
101406       {
101407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101408       };
101409     }
101410   }
101411 }
101412
101413
101414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
101415   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101416   uint16_t arg2 ;
101417   uint16_t arg3 ;
101418   uint16_t arg4 ;
101419   uint16_t arg5 ;
101420
101421   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101422   arg2 = (uint16_t)jarg2;
101423   arg3 = (uint16_t)jarg3;
101424   arg4 = (uint16_t)jarg4;
101425   arg5 = (uint16_t)jarg5;
101426   {
101427     try {
101428       (arg1)->Crop(arg2,arg3,arg4,arg5);
101429     } catch (std::out_of_range& e) {
101430       {
101431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101432       };
101433     } catch (std::exception& e) {
101434       {
101435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101436       };
101437     } catch (...) {
101438       {
101439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101440       };
101441     }
101442   }
101443 }
101444
101445
101446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
101447   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101448   uint16_t arg2 ;
101449   uint16_t arg3 ;
101450
101451   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101452   arg2 = (uint16_t)jarg2;
101453   arg3 = (uint16_t)jarg3;
101454   {
101455     try {
101456       (arg1)->Resize(arg2,arg3);
101457     } catch (std::out_of_range& e) {
101458       {
101459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101460       };
101461     } catch (std::exception& e) {
101462       {
101463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101464       };
101465     } catch (...) {
101466       {
101467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101468       };
101469     }
101470   }
101471 }
101472
101473 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void * jarg2) {
101474   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101475   Dali::Degree * arg2 ;
101476
101477   bool result = false;
101478
101479   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101480   arg2 = (Dali::Degree *)jarg2;
101481   {
101482     try {
101483       result = (arg1)->Rotate(*arg2);
101484     } catch (std::out_of_range& e) {
101485       {
101486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
101487       };
101488     } catch (std::exception& e) {
101489       {
101490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
101491       };
101492     } catch (...) {
101493       {
101494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
101495       };
101496     }
101497   }
101498   return result;
101499 }
101500
101501
101502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101503   void * jresult ;
101504   std::string *arg1 = 0 ;
101505   Dali::ImageDimensions arg2 ;
101506   Dali::FittingMode::Type arg3 ;
101507   Dali::SamplingMode::Type arg4 ;
101508   bool arg5 ;
101509   Dali::ImageDimensions *argp2 ;
101510   Dali::Devel::PixelBuffer result;
101511
101512   if (!jarg1) {
101513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101514     return 0;
101515   }
101516   std::string arg1_str(jarg1);
101517   arg1 = &arg1_str;
101518   argp2 = (Dali::ImageDimensions *)jarg2;
101519   if (!argp2) {
101520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101521     return 0;
101522   }
101523   arg2 = *argp2;
101524   arg3 = (Dali::FittingMode::Type)jarg3;
101525   arg4 = (Dali::SamplingMode::Type)jarg4;
101526   arg5 = jarg5 ? true : false;
101527   {
101528     try {
101529       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101530     } catch (std::out_of_range& e) {
101531       {
101532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101533       };
101534     } catch (std::exception& e) {
101535       {
101536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101537       };
101538     } catch (...) {
101539       {
101540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101541       };
101542     }
101543   }
101544   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101545
101546   return jresult;
101547 }
101548
101549
101550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101551   void * jresult ;
101552   std::string *arg1 = 0 ;
101553   Dali::ImageDimensions arg2 ;
101554   Dali::FittingMode::Type arg3 ;
101555   Dali::SamplingMode::Type arg4 ;
101556   Dali::ImageDimensions *argp2 ;
101557   Dali::Devel::PixelBuffer result;
101558
101559   if (!jarg1) {
101560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101561     return 0;
101562   }
101563   std::string arg1_str(jarg1);
101564   arg1 = &arg1_str;
101565   argp2 = (Dali::ImageDimensions *)jarg2;
101566   if (!argp2) {
101567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101568     return 0;
101569   }
101570   arg2 = *argp2;
101571   arg3 = (Dali::FittingMode::Type)jarg3;
101572   arg4 = (Dali::SamplingMode::Type)jarg4;
101573   {
101574     try {
101575       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
101576     } catch (std::out_of_range& e) {
101577       {
101578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101579       };
101580     } catch (std::exception& e) {
101581       {
101582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101583       };
101584     } catch (...) {
101585       {
101586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101587       };
101588     }
101589   }
101590   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101591
101592   return jresult;
101593 }
101594
101595
101596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101597   void * jresult ;
101598   std::string *arg1 = 0 ;
101599   Dali::ImageDimensions arg2 ;
101600   Dali::FittingMode::Type arg3 ;
101601   Dali::ImageDimensions *argp2 ;
101602   Dali::Devel::PixelBuffer result;
101603
101604   if (!jarg1) {
101605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101606     return 0;
101607   }
101608   std::string arg1_str(jarg1);
101609   arg1 = &arg1_str;
101610   argp2 = (Dali::ImageDimensions *)jarg2;
101611   if (!argp2) {
101612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101613     return 0;
101614   }
101615   arg2 = *argp2;
101616   arg3 = (Dali::FittingMode::Type)jarg3;
101617   {
101618     try {
101619       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
101620     } catch (std::out_of_range& e) {
101621       {
101622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101623       };
101624     } catch (std::exception& e) {
101625       {
101626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101627       };
101628     } catch (...) {
101629       {
101630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101631       };
101632     }
101633   }
101634   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101635
101636   return jresult;
101637 }
101638
101639
101640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
101641   void * jresult ;
101642   std::string *arg1 = 0 ;
101643   Dali::ImageDimensions arg2 ;
101644   Dali::ImageDimensions *argp2 ;
101645   Dali::Devel::PixelBuffer result;
101646
101647   if (!jarg1) {
101648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101649     return 0;
101650   }
101651   std::string arg1_str(jarg1);
101652   arg1 = &arg1_str;
101653   argp2 = (Dali::ImageDimensions *)jarg2;
101654   if (!argp2) {
101655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101656     return 0;
101657   }
101658   arg2 = *argp2;
101659   {
101660     try {
101661       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
101662     } catch (std::out_of_range& e) {
101663       {
101664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101665       };
101666     } catch (std::exception& e) {
101667       {
101668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101669       };
101670     } catch (...) {
101671       {
101672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101673       };
101674     }
101675   }
101676   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101677
101678   return jresult;
101679 }
101680
101681
101682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
101683   void * jresult ;
101684   std::string *arg1 = 0 ;
101685   Dali::Devel::PixelBuffer result;
101686
101687   if (!jarg1) {
101688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101689     return 0;
101690   }
101691   std::string arg1_str(jarg1);
101692   arg1 = &arg1_str;
101693   {
101694     try {
101695       result = Dali::LoadImageFromFile((std::string const &)*arg1);
101696     } catch (std::out_of_range& e) {
101697       {
101698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101699       };
101700     } catch (std::exception& e) {
101701       {
101702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101703       };
101704     } catch (...) {
101705       {
101706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101707       };
101708     }
101709   }
101710   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101711
101712   return jresult;
101713 }
101714
101715
101716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101717   void * jresult ;
101718   std::string *arg1 = 0 ;
101719   Dali::ImageDimensions arg2 ;
101720   Dali::FittingMode::Type arg3 ;
101721   Dali::SamplingMode::Type arg4 ;
101722   bool arg5 ;
101723   Dali::ImageDimensions *argp2 ;
101724   Dali::ImageDimensions result;
101725
101726   if (!jarg1) {
101727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101728     return 0;
101729   }
101730   std::string arg1_str(jarg1);
101731   arg1 = &arg1_str;
101732   argp2 = (Dali::ImageDimensions *)jarg2;
101733   if (!argp2) {
101734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101735     return 0;
101736   }
101737   arg2 = *argp2;
101738   arg3 = (Dali::FittingMode::Type)jarg3;
101739   arg4 = (Dali::SamplingMode::Type)jarg4;
101740   arg5 = jarg5 ? true : false;
101741   {
101742     try {
101743       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101744     } catch (std::out_of_range& e) {
101745       {
101746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101747       };
101748     } catch (std::exception& e) {
101749       {
101750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101751       };
101752     } catch (...) {
101753       {
101754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101755       };
101756     }
101757   }
101758   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101759
101760   return jresult;
101761 }
101762
101763
101764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101765   void * jresult ;
101766   std::string *arg1 = 0 ;
101767   Dali::ImageDimensions arg2 ;
101768   Dali::FittingMode::Type arg3 ;
101769   Dali::SamplingMode::Type arg4 ;
101770   Dali::ImageDimensions *argp2 ;
101771   Dali::ImageDimensions result;
101772
101773   if (!jarg1) {
101774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101775     return 0;
101776   }
101777   std::string arg1_str(jarg1);
101778   arg1 = &arg1_str;
101779   argp2 = (Dali::ImageDimensions *)jarg2;
101780   if (!argp2) {
101781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101782     return 0;
101783   }
101784   arg2 = *argp2;
101785   arg3 = (Dali::FittingMode::Type)jarg3;
101786   arg4 = (Dali::SamplingMode::Type)jarg4;
101787   {
101788     try {
101789       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
101790     } catch (std::out_of_range& e) {
101791       {
101792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101793       };
101794     } catch (std::exception& e) {
101795       {
101796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101797       };
101798     } catch (...) {
101799       {
101800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101801       };
101802     }
101803   }
101804   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101805
101806   return jresult;
101807 }
101808
101809
101810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101811   void * jresult ;
101812   std::string *arg1 = 0 ;
101813   Dali::ImageDimensions arg2 ;
101814   Dali::FittingMode::Type arg3 ;
101815   Dali::ImageDimensions *argp2 ;
101816   Dali::ImageDimensions result;
101817
101818   if (!jarg1) {
101819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101820     return 0;
101821   }
101822   std::string arg1_str(jarg1);
101823   arg1 = &arg1_str;
101824   argp2 = (Dali::ImageDimensions *)jarg2;
101825   if (!argp2) {
101826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101827     return 0;
101828   }
101829   arg2 = *argp2;
101830   arg3 = (Dali::FittingMode::Type)jarg3;
101831   {
101832     try {
101833       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
101834     } catch (std::out_of_range& e) {
101835       {
101836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101837       };
101838     } catch (std::exception& e) {
101839       {
101840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101841       };
101842     } catch (...) {
101843       {
101844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101845       };
101846     }
101847   }
101848   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101849
101850   return jresult;
101851 }
101852
101853
101854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
101855   void * jresult ;
101856   std::string *arg1 = 0 ;
101857   Dali::ImageDimensions arg2 ;
101858   Dali::ImageDimensions *argp2 ;
101859   Dali::ImageDimensions result;
101860
101861   if (!jarg1) {
101862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101863     return 0;
101864   }
101865   std::string arg1_str(jarg1);
101866   arg1 = &arg1_str;
101867   argp2 = (Dali::ImageDimensions *)jarg2;
101868   if (!argp2) {
101869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101870     return 0;
101871   }
101872   arg2 = *argp2;
101873   {
101874     try {
101875       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
101876     } catch (std::out_of_range& e) {
101877       {
101878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101879       };
101880     } catch (std::exception& e) {
101881       {
101882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101883       };
101884     } catch (...) {
101885       {
101886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101887       };
101888     }
101889   }
101890   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101891
101892   return jresult;
101893 }
101894
101895
101896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
101897   void * jresult ;
101898   std::string *arg1 = 0 ;
101899   Dali::ImageDimensions result;
101900
101901   if (!jarg1) {
101902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101903     return 0;
101904   }
101905   std::string arg1_str(jarg1);
101906   arg1 = &arg1_str;
101907   {
101908     try {
101909       result = Dali::GetClosestImageSize((std::string const &)*arg1);
101910     } catch (std::out_of_range& e) {
101911       {
101912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101913       };
101914     } catch (std::exception& e) {
101915       {
101916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101917       };
101918     } catch (...) {
101919       {
101920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101921       };
101922     }
101923   }
101924   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101925
101926   return jresult;
101927 }
101928
101929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
101930   void * jresult ;
101931   std::string *arg1 = 0 ;
101932   Dali::ImageDimensions result;
101933
101934   if (!jarg1) {
101935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101936     return 0;
101937   }
101938   std::string arg1_str(jarg1);
101939   arg1 = &arg1_str;
101940   {
101941     try {
101942       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
101943     } catch (std::out_of_range& e) {
101944       {
101945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101946       };
101947     } catch (std::exception& e) {
101948       {
101949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101950       };
101951     } catch (...) {
101952       {
101953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101954       };
101955     }
101956   }
101957   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101958
101959   return jresult;
101960 }
101961
101962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101963   void * jresult ;
101964   std::string *arg1 = 0 ;
101965   Dali::ImageDimensions arg2 ;
101966   Dali::FittingMode::Type arg3 ;
101967   Dali::SamplingMode::Type arg4 ;
101968   bool arg5 ;
101969   Dali::ImageDimensions *argp2 ;
101970   Dali::Devel::PixelBuffer result;
101971
101972   if (!jarg1) {
101973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101974     return 0;
101975   }
101976   std::string arg1_str(jarg1);
101977   arg1 = &arg1_str;
101978   argp2 = (Dali::ImageDimensions *)jarg2;
101979   if (!argp2) {
101980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101981     return 0;
101982   }
101983   arg2 = *argp2;
101984   arg3 = (Dali::FittingMode::Type)jarg3;
101985   arg4 = (Dali::SamplingMode::Type)jarg4;
101986   arg5 = jarg5 ? true : false;
101987   {
101988     try {
101989       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101990     } catch (std::out_of_range& e) {
101991       {
101992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101993       };
101994     } catch (std::exception& e) {
101995       {
101996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101997       };
101998     } catch (...) {
101999       {
102000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102001       };
102002     }
102003   }
102004   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102005
102006   return jresult;
102007 }
102008
102009
102010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102011   void * jresult ;
102012   std::string *arg1 = 0 ;
102013   Dali::ImageDimensions arg2 ;
102014   Dali::FittingMode::Type arg3 ;
102015   Dali::SamplingMode::Type arg4 ;
102016   Dali::ImageDimensions *argp2 ;
102017   Dali::Devel::PixelBuffer result;
102018
102019   if (!jarg1) {
102020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102021     return 0;
102022   }
102023   std::string arg1_str(jarg1);
102024   arg1 = &arg1_str;
102025   argp2 = (Dali::ImageDimensions *)jarg2;
102026   if (!argp2) {
102027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102028     return 0;
102029   }
102030   arg2 = *argp2;
102031   arg3 = (Dali::FittingMode::Type)jarg3;
102032   arg4 = (Dali::SamplingMode::Type)jarg4;
102033   {
102034     try {
102035       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
102036     } catch (std::out_of_range& e) {
102037       {
102038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102039       };
102040     } catch (std::exception& e) {
102041       {
102042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102043       };
102044     } catch (...) {
102045       {
102046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102047       };
102048     }
102049   }
102050   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102051
102052   return jresult;
102053 }
102054
102055
102056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102057   void * jresult ;
102058   std::string *arg1 = 0 ;
102059   Dali::ImageDimensions arg2 ;
102060   Dali::FittingMode::Type arg3 ;
102061   Dali::ImageDimensions *argp2 ;
102062   Dali::Devel::PixelBuffer result;
102063
102064   if (!jarg1) {
102065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102066     return 0;
102067   }
102068   std::string arg1_str(jarg1);
102069   arg1 = &arg1_str;
102070   argp2 = (Dali::ImageDimensions *)jarg2;
102071   if (!argp2) {
102072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102073     return 0;
102074   }
102075   arg2 = *argp2;
102076   arg3 = (Dali::FittingMode::Type)jarg3;
102077   {
102078     try {
102079       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
102080     } catch (std::out_of_range& e) {
102081       {
102082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102083       };
102084     } catch (std::exception& e) {
102085       {
102086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102087       };
102088     } catch (...) {
102089       {
102090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102091       };
102092     }
102093   }
102094   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102095
102096   return jresult;
102097 }
102098
102099
102100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
102101   void * jresult ;
102102   std::string *arg1 = 0 ;
102103   Dali::ImageDimensions arg2 ;
102104   Dali::ImageDimensions *argp2 ;
102105   Dali::Devel::PixelBuffer result;
102106
102107   if (!jarg1) {
102108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102109     return 0;
102110   }
102111   std::string arg1_str(jarg1);
102112   arg1 = &arg1_str;
102113   argp2 = (Dali::ImageDimensions *)jarg2;
102114   if (!argp2) {
102115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102116     return 0;
102117   }
102118   arg2 = *argp2;
102119   {
102120     try {
102121       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
102122     } catch (std::out_of_range& e) {
102123       {
102124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102125       };
102126     } catch (std::exception& e) {
102127       {
102128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102129       };
102130     } catch (...) {
102131       {
102132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102133       };
102134     }
102135   }
102136   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102137
102138   return jresult;
102139 }
102140
102141
102142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
102143   void * jresult ;
102144   std::string *arg1 = 0 ;
102145   Dali::Devel::PixelBuffer result;
102146
102147   if (!jarg1) {
102148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102149     return 0;
102150   }
102151   std::string arg1_str(jarg1);
102152   arg1 = &arg1_str;
102153   {
102154     try {
102155       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
102156     } catch (std::out_of_range& e) {
102157       {
102158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102159       };
102160     } catch (std::exception& e) {
102161       {
102162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102163       };
102164     } catch (...) {
102165       {
102166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102167       };
102168     }
102169   }
102170   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102171
102172   return jresult;
102173 }
102174
102175
102176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
102177   void * jresult ;
102178   Dali::Toolkit::WebView result;
102179
102180   {
102181     try {
102182       result = Dali::Toolkit::WebView::New();
102183     } catch (std::out_of_range& e) {
102184       {
102185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102186       };
102187     } catch (std::exception& e) {
102188       {
102189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102190       };
102191     } catch (Dali::DaliException e) {
102192       {
102193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102194       };
102195     } catch (...) {
102196       {
102197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102198       };
102199     }
102200   }
102201   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102202   return jresult;
102203 }
102204
102205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
102206   void * jresult ;
102207   Dali::Toolkit::WebView result;
102208
102209   std::string *arg1;
102210   std::string *arg2;
102211
102212   if (!jarg1) {
102213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
102214     return 0;
102215   }
102216   if (!jarg2) {
102217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
102218     return 0;
102219   }
102220
102221   std::string jarg1_str = std::string(jarg1);
102222   std::string jarg2_str = std::string(jarg2);
102223
102224   arg1 = &jarg1_str;
102225   arg2 = &jarg2_str;
102226
102227   {
102228     try {
102229       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
102230     } catch (std::out_of_range& e) {
102231       {
102232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102233       };
102234     } catch (std::exception& e) {
102235       {
102236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102237       };
102238     } catch (Dali::DaliException e) {
102239       {
102240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102241       };
102242     } catch (...) {
102243       {
102244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102245       };
102246     }
102247   }
102248   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102249   return jresult;
102250 }
102251
102252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
102253   void * jresult ;
102254   Dali::Toolkit::WebView *arg1 = 0 ;
102255   Dali::Toolkit::WebView *result = 0 ;
102256
102257   arg1 = (Dali::Toolkit::WebView *)jarg1;
102258   if (!arg1) {
102259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
102260     return 0;
102261   }
102262   {
102263     try {
102264       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
102265     } catch (std::out_of_range& e) {
102266       {
102267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102268       };
102269     } catch (std::exception& e) {
102270       {
102271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102272       };
102273     } catch (Dali::DaliException e) {
102274       {
102275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102276       };
102277     } catch (...) {
102278       {
102279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102280       };
102281     }
102282   }
102283   jresult = (void *)result;
102284   return jresult;
102285 }
102286
102287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
102288   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102289   arg1 = (Dali::Toolkit::WebView *)jarg1;
102290   {
102291     try {
102292       delete arg1;
102293     } catch (std::out_of_range& e) {
102294       {
102295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102296       };
102297     } catch (std::exception& e) {
102298       {
102299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102300       };
102301     } catch (Dali::DaliException e) {
102302       {
102303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102304       };
102305     } catch (...) {
102306       {
102307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102308       };
102309     }
102310   }
102311 }
102312
102313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
102314   void * jresult ;
102315   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102316   Dali::Toolkit::WebView *arg2 = 0 ;
102317   Dali::Toolkit::WebView *result = 0 ;
102318
102319   arg1 = (Dali::Toolkit::WebView *)jarg1;
102320   arg2 = (Dali::Toolkit::WebView *)jarg2;
102321   if (!arg2) {
102322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
102323     return 0;
102324   }
102325   {
102326     try {
102327       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
102328     } catch (std::out_of_range& e) {
102329       {
102330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102331       };
102332     } catch (std::exception& e) {
102333       {
102334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102335       };
102336     } catch (Dali::DaliException e) {
102337       {
102338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102339       };
102340     } catch (...) {
102341       {
102342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102343       };
102344     }
102345   }
102346   jresult = (void *)result;
102347   return jresult;
102348 }
102349
102350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
102351   void * jresult ;
102352   Dali::BaseHandle arg1 ;
102353   Dali::BaseHandle *argp1 ;
102354   Dali::Toolkit::WebView result;
102355
102356   argp1 = (Dali::BaseHandle *)jarg1;
102357   if (!argp1) {
102358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
102359     return 0;
102360   }
102361   arg1 = *argp1;
102362   {
102363     try {
102364       result = Dali::Toolkit::WebView::DownCast(arg1);
102365     } catch (std::out_of_range& e) {
102366       {
102367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102368       };
102369     } catch (std::exception& e) {
102370       {
102371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102372       };
102373     } catch (Dali::DaliException e) {
102374       {
102375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102376       };
102377     } catch (...) {
102378       {
102379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102380       };
102381     }
102382   }
102383   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102384   return jresult;
102385 }
102386
102387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
102388   return (int) Dali::Toolkit::WebView::Property::URL;
102389 }
102390
102391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
102392   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
102393 }
102394
102395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
102396   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
102397 }
102398
102399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
102400   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
102401 }
102402
102403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
102404   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
102405 }
102406
102407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
102408   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
102409 }
102410
102411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
102412   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
102413 }
102414
102415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
102416   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
102417 }
102418
102419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
102420   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102421   std::string *arg2;
102422
102423   arg1 = (Dali::Toolkit::WebView *)jarg1;
102424
102425   if (!jarg2) {
102426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102427     return;
102428   }
102429
102430   std::string jarg2str = std::string(jarg2);
102431   arg2 = &jarg2str;
102432   {
102433     try {
102434       (arg1)->LoadUrl((std::string const &)*arg2);
102435     } catch (std::out_of_range& e) {
102436       {
102437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102438       };
102439     } catch (std::exception& e) {
102440       {
102441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102442       };
102443     } catch (Dali::DaliException e) {
102444       {
102445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102446       };
102447     } catch (...) {
102448       {
102449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102450       };
102451     }
102452   }
102453 }
102454
102455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
102456   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102457   std::string *arg2;
102458
102459   arg1 = (Dali::Toolkit::WebView *)jarg1;
102460   if (!jarg2) {
102461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102462     return;
102463   }
102464   std::string jarg2str = std::string(jarg2);
102465   arg2 = &jarg2str;
102466   {
102467     try {
102468       (arg1)->LoadHTMLString((std::string const &)*arg2);
102469     } catch (std::out_of_range& e) {
102470       {
102471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102472       };
102473     } catch (std::exception& e) {
102474       {
102475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102476       };
102477     } catch (Dali::DaliException e) {
102478       {
102479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102480       };
102481     } catch (...) {
102482       {
102483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102484       };
102485     }
102486   }
102487 }
102488
102489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
102490   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102491
102492   arg1 = (Dali::Toolkit::WebView *)jarg1;
102493   {
102494     try {
102495       (arg1)->Reload();
102496     } catch (std::out_of_range& e) {
102497       {
102498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102499       };
102500     } catch (std::exception& e) {
102501       {
102502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102503       };
102504     } catch (Dali::DaliException e) {
102505       {
102506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102507       };
102508     } catch (...) {
102509       {
102510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102511       };
102512     }
102513   }
102514 }
102515
102516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
102517   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102518
102519   arg1 = (Dali::Toolkit::WebView *)jarg1;
102520   {
102521     try {
102522       (arg1)->StopLoading();
102523     } catch (std::out_of_range& e) {
102524       {
102525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102526       };
102527     } catch (std::exception& e) {
102528       {
102529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102530       };
102531     } catch (Dali::DaliException e) {
102532       {
102533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102534       };
102535     } catch (...) {
102536       {
102537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102538       };
102539     }
102540   }
102541 }
102542
102543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
102544   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102545
102546   arg1 = (Dali::Toolkit::WebView *)jarg1;
102547   {
102548     try {
102549       (arg1)->Suspend();
102550     } catch (std::out_of_range& e) {
102551       {
102552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102553       };
102554     } catch (std::exception& e) {
102555       {
102556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102557       };
102558     } catch (Dali::DaliException e) {
102559       {
102560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102561       };
102562     } catch (...) {
102563       {
102564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102565       };
102566     }
102567   }
102568 }
102569
102570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
102571   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102572
102573   arg1 = (Dali::Toolkit::WebView *)jarg1;
102574   {
102575     try {
102576       (arg1)->Resume();
102577     } catch (std::out_of_range& e) {
102578       {
102579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102580       };
102581     } catch (std::exception& e) {
102582       {
102583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102584       };
102585     } catch (Dali::DaliException e) {
102586       {
102587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102588       };
102589     } catch (...) {
102590       {
102591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102592       };
102593     }
102594   }
102595 }
102596
102597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
102598   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102599
102600   arg1 = (Dali::Toolkit::WebView *)jarg1;
102601   {
102602     try {
102603       (arg1)->GoBack();
102604     } catch (std::out_of_range& e) {
102605       {
102606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102607       };
102608     } catch (std::exception& e) {
102609       {
102610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102611       };
102612     } catch (Dali::DaliException e) {
102613       {
102614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102615       };
102616     } catch (...) {
102617       {
102618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102619       };
102620     }
102621   }
102622 }
102623
102624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
102625   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102626
102627   arg1 = (Dali::Toolkit::WebView *)jarg1;
102628   {
102629     try {
102630       (arg1)->GoForward();
102631     } catch (std::out_of_range& e) {
102632       {
102633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102634       };
102635     } catch (std::exception& e) {
102636       {
102637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102638       };
102639     } catch (Dali::DaliException e) {
102640       {
102641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102642       };
102643     } catch (...) {
102644       {
102645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102646       };
102647     }
102648   }
102649 }
102650
102651 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
102652   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102653   bool ret;
102654
102655   arg1 = (Dali::Toolkit::WebView *)jarg1;
102656   {
102657     try {
102658       ret = (arg1)->CanGoBack();
102659     } catch (std::out_of_range& e) {
102660       {
102661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
102662       };
102663     } catch (std::exception& e) {
102664       {
102665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
102666       };
102667     } catch (Dali::DaliException e) {
102668       {
102669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
102670       };
102671     } catch (...) {
102672       {
102673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
102674       };
102675     }
102676   }
102677   return ret;
102678 }
102679
102680 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
102681   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102682   bool ret;
102683
102684   arg1 = (Dali::Toolkit::WebView *)jarg1;
102685   {
102686     try {
102687       ret = (arg1)->CanGoForward();
102688     } catch (std::out_of_range& e) {
102689       {
102690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
102691       };
102692     } catch (std::exception& e) {
102693       {
102694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
102695       };
102696     } catch (Dali::DaliException e) {
102697       {
102698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
102699       };
102700     } catch (...) {
102701       {
102702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
102703       };
102704     }
102705   }
102706   return ret;
102707 }
102708
102709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
102710   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102711   std::string *arg2;
102712
102713   arg1 = (Dali::Toolkit::WebView *)jarg1;
102714   if (!jarg2) {
102715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102716     return;
102717   }
102718   std::string jarg2_str = std::string(jarg2);
102719   arg2 = &jarg2_str;
102720
102721   {
102722     try {
102723       if (jarg3) {
102724         void (*handler)(char*) = (void (*)(char*)) jarg3;
102725         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
102726           handler(SWIG_csharp_string_callback(result.c_str()));
102727         });
102728       } else {
102729         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
102730       }
102731     } catch (std::out_of_range& e) {
102732       {
102733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102734       };
102735     } catch (std::exception& e) {
102736       {
102737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102738       };
102739     } catch (Dali::DaliException e) {
102740       {
102741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102742       };
102743     } catch (...) {
102744       {
102745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102746       };
102747     }
102748   }
102749 }
102750
102751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
102752 {
102753   if (!jarg2) {
102754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102755     return;
102756   }
102757
102758   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102759   std::string exposedObjectName = jarg2;
102760   void (*handler)(char*) = (void (*)(char*)) jarg3;
102761
102762   {
102763     try {
102764       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
102765         handler(SWIG_csharp_string_callback(message.c_str()));
102766       });
102767     } catch (std::out_of_range& e) {
102768       {
102769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102770       };
102771     } catch (std::exception& e) {
102772       {
102773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102774       };
102775     } catch (Dali::DaliException e) {
102776       {
102777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102778       };
102779     } catch (...) {
102780       {
102781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102782       };
102783     }
102784   }
102785 }
102786
102787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
102788   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102789
102790   arg1 = (Dali::Toolkit::WebView *)jarg1;
102791   {
102792     try {
102793       (arg1)->ClearHistory();
102794     } catch (std::out_of_range& e) {
102795       {
102796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102797       };
102798     } catch (std::exception& e) {
102799       {
102800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102801       };
102802     } catch (Dali::DaliException e) {
102803       {
102804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102805       };
102806     } catch (...) {
102807       {
102808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102809       };
102810     }
102811   }
102812 }
102813
102814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
102815   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102816
102817   arg1 = (Dali::Toolkit::WebView *)jarg1;
102818   {
102819     try {
102820       (arg1)->ClearCache();
102821     } catch (std::out_of_range& e) {
102822       {
102823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102824       };
102825     } catch (std::exception& e) {
102826       {
102827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102828       };
102829     } catch (Dali::DaliException e) {
102830       {
102831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102832       };
102833     } catch (...) {
102834       {
102835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102836       };
102837     }
102838   }
102839 }
102840
102841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
102842   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102843
102844   arg1 = (Dali::Toolkit::WebView *)jarg1;
102845   {
102846     try {
102847       (arg1)->ClearCookies();
102848     } catch (std::out_of_range& e) {
102849       {
102850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102851       };
102852     } catch (std::exception& e) {
102853       {
102854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102855       };
102856     } catch (Dali::DaliException e) {
102857       {
102858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102859       };
102860     } catch (...) {
102861       {
102862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102863       };
102864     }
102865   }
102866 }
102867
102868 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
102869     return (Dali::Toolkit::Control *)jarg1;
102870 }
102871
102872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
102873   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102874   SignalConverter::WebViewPageLoadSignal* result = NULL;
102875   {
102876     try {
102877       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
102878     } catch (std::out_of_range& e) {
102879       {
102880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102881       };
102882     } catch (std::exception& e) {
102883       {
102884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102885       };
102886     } catch (Dali::DaliException e) {
102887       {
102888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102889       };
102890     } catch (...) {
102891       {
102892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102893       };
102894     }
102895   }
102896   return (void*) result;
102897 }
102898
102899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
102900   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102901   SignalConverter::WebViewPageLoadSignal* result = NULL;
102902   {
102903     try {
102904       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
102905     } catch (std::out_of_range& e) {
102906       {
102907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102908       };
102909     } catch (std::exception& e) {
102910       {
102911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102912       };
102913     } catch (Dali::DaliException e) {
102914       {
102915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102916       };
102917     } catch (...) {
102918       {
102919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102920       };
102921     }
102922   }
102923   return (void*) result;
102924 }
102925
102926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
102927 {
102928   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102929   {
102930     try {
102931       delete object;
102932     } catch (std::out_of_range& e) {
102933       {
102934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102935       };
102936     } catch (std::exception& e) {
102937       {
102938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102939       };
102940     } catch (Dali::DaliException e) {
102941       {
102942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102943       };
102944     } catch (...) {
102945       {
102946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102947       };
102948     }
102949   }
102950 }
102951
102952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
102953 {
102954   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102955   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
102956   {
102957     try {
102958       proxy->Connect(callback);
102959     } catch (std::out_of_range& e) {
102960       {
102961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102962       };
102963     } catch (std::exception& e) {
102964       {
102965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102966       };
102967     } catch (Dali::DaliException e) {
102968       {
102969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102970       };
102971     } catch (...) {
102972       {
102973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102974       };
102975     }
102976   }
102977 }
102978
102979
102980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
102981   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102982   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
102983   {
102984     try {
102985       proxy->Disconnect(callback);
102986     } catch (std::out_of_range& e) {
102987       {
102988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102989       };
102990     } catch (std::exception& e) {
102991       {
102992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102993       };
102994     } catch (Dali::DaliException e) {
102995       {
102996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102997       };
102998     } catch (...) {
102999       {
103000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103001       };
103002     }
103003   }
103004 }
103005
103006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
103007   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103008   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
103009   {
103010     try {
103011       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
103012     } catch (std::out_of_range& e) {
103013       {
103014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103015       };
103016     } catch (std::exception& e) {
103017       {
103018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103019       };
103020     } catch (Dali::DaliException e) {
103021       {
103022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103023       };
103024     } catch (...) {
103025       {
103026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103027       };
103028     }
103029   }
103030   return (void*) result;
103031 }
103032
103033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
103034 {
103035   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103036   {
103037     try {
103038       delete object;
103039     } catch (std::out_of_range& e) {
103040       {
103041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103042       };
103043     } catch (std::exception& e) {
103044       {
103045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103046       };
103047     } catch (Dali::DaliException e) {
103048       {
103049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103050       };
103051     } catch (...) {
103052       {
103053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103054       };
103055     }
103056   }
103057 }
103058
103059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
103060 {
103061   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103062   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
103063   {
103064     try {
103065       proxy->Connect(callback);
103066     } catch (std::out_of_range& e) {
103067       {
103068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103069       };
103070     } catch (std::exception& e) {
103071       {
103072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103073       };
103074     } catch (Dali::DaliException e) {
103075       {
103076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103077       };
103078     } catch (...) {
103079       {
103080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103081       };
103082     }
103083   }
103084 }
103085
103086
103087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
103088   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103089   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
103090   {
103091     try {
103092       proxy->Disconnect(callback);
103093     } catch (std::out_of_range& e) {
103094       {
103095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103096       };
103097     } catch (std::exception& e) {
103098       {
103099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103100       };
103101     } catch (Dali::DaliException e) {
103102       {
103103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103104       };
103105     } catch (...) {
103106       {
103107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103108       };
103109     }
103110   }
103111 }
103112
103113 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
103114   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
103115   char * jresult = SWIG_csharp_string_callback((const char *)result);
103116   return jresult;
103117 }
103118
103119 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
103120   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
103121   return result;
103122 }
103123
103124
103125 struct NativeImageSourcePtrHandle
103126 {
103127   NativeImageSourcePtr Ptr;
103128 };
103129
103130 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
103131 {
103132   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
103133   return (NativeImageInterface*)(arg1);
103134 }
103135
103136 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
103137 {
103138   void* jresult;
103139   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
103140   {
103141     try {
103142       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
103143     }
103144     catch (std::out_of_range & e) {
103145       {
103146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103147       };
103148     }
103149     catch (std::exception & e) {
103150       {
103151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103152       };
103153     }
103154     catch (Dali::DaliException e) {
103155       {
103156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103157       };
103158     }
103159     catch (...) {
103160       {
103161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103162       };
103163     }
103164   }
103165   jresult = (void *)handle;
103166   return jresult;
103167 }
103168
103169 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
103170 {
103171   void* jresult;
103172   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
103173   jresult = (void*)( handle->Ptr.Get() );
103174   return jresult;
103175 }
103176
103177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
103178   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
103179   {
103180     try {
103181       delete arg1;
103182     }
103183     catch (std::out_of_range & e) {
103184       {
103185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
103186       };
103187     }
103188     catch (std::exception & e) {
103189       {
103190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
103191       };
103192     }
103193     catch (Dali::DaliException e) {
103194       {
103195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
103196       };
103197     }
103198     catch (...) {
103199       {
103200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
103201       };
103202     }
103203   }
103204 }
103205
103206 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
103207 {
103208   void* jresult;
103209   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
103210   uint16_t* arg2 = (uint16_t*)(jarg2);
103211   uint16_t* arg3 = (uint16_t*)(jarg3);
103212   uint16_t* arg4 = (uint16_t*)(jarg4);
103213   {
103214     try {
103215       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
103216     }
103217     catch (std::out_of_range & e) {
103218       {
103219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103220       };
103221     }
103222     catch (std::exception & e) {
103223       {
103224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103225       };
103226     }
103227     catch (Dali::DaliException e) {
103228       {
103229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103230       };
103231     }
103232     catch (...) {
103233       {
103234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103235       };
103236     }
103237   }
103238   return jresult;
103239 }
103240
103241 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
103242 {
103243   bool jresult;
103244   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
103245
103246   {
103247     try {
103248       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
103249     }
103250     catch (std::out_of_range & e) {
103251       {
103252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103253       };
103254     }
103255     catch (std::exception & e) {
103256       {
103257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103258       };
103259     }
103260     catch (Dali::DaliException e) {
103261       {
103262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103263       };
103264     }
103265     catch (...) {
103266       {
103267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103268       };
103269     }
103270   }
103271   return jresult;
103272 }
103273
103274
103275 #ifdef __cplusplus
103276 }
103277 #endif
103278