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       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33808     } catch (std::out_of_range& e) {
33809       {
33810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33811       };
33812     } catch (std::exception& e) {
33813       {
33814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33815       };
33816     } catch (Dali::DaliException e) {
33817       {
33818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33819       };
33820     } catch (...) {
33821       {
33822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33823       };
33824     }
33825   }
33826
33827   jresult = SWIG_csharp_string_callback(result->c_str());
33828   return jresult;
33829 }
33830
33831
33832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33833   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33834   std::string *arg2 = 0 ;
33835
33836   arg1 = (Dali::Actor *)jarg1;
33837   if (!jarg2) {
33838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33839     return ;
33840   }
33841   std::string arg2_str(jarg2);
33842   arg2 = &arg2_str;
33843   {
33844     try {
33845       (arg1)->SetName((std::string const &)*arg2);
33846     } catch (std::out_of_range& e) {
33847       {
33848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33849       };
33850     } catch (std::exception& e) {
33851       {
33852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33853       };
33854     } catch (Dali::DaliException e) {
33855       {
33856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33857       };
33858     } catch (...) {
33859       {
33860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33861       };
33862     }
33863   }
33864
33865
33866   //argout typemap for const std::string&
33867
33868 }
33869
33870
33871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33872   unsigned int jresult ;
33873   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33874   unsigned int result;
33875
33876   arg1 = (Dali::Actor *)jarg1;
33877
33878   if(!arg1) {
33879     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
33880     return -1;
33881   }
33882
33883   {
33884     try {
33885       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33886     } catch (std::out_of_range& e) {
33887       {
33888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33889       };
33890     } catch (std::exception& e) {
33891       {
33892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33893       };
33894     } catch (Dali::DaliException e) {
33895       {
33896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33897       };
33898     } catch (...) {
33899       {
33900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33901       };
33902     }
33903   }
33904
33905   jresult = result;
33906   return jresult;
33907 }
33908
33909
33910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33911   unsigned int jresult ;
33912   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33913   bool result;
33914
33915   arg1 = (Dali::Actor *)jarg1;
33916   {
33917     try {
33918       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33919     } catch (std::out_of_range& e) {
33920       {
33921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33922       };
33923     } catch (std::exception& e) {
33924       {
33925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33926       };
33927     } catch (Dali::DaliException e) {
33928       {
33929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33930       };
33931     } catch (...) {
33932       {
33933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33934       };
33935     }
33936   }
33937
33938   jresult = result;
33939   return jresult;
33940 }
33941
33942
33943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33944   unsigned int jresult ;
33945   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33946   bool result;
33947
33948   arg1 = (Dali::Actor *)jarg1;
33949   {
33950     try {
33951       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33952     } catch (std::out_of_range& e) {
33953       {
33954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33955       };
33956     } catch (std::exception& e) {
33957       {
33958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33959       };
33960     } catch (Dali::DaliException e) {
33961       {
33962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33963       };
33964     } catch (...) {
33965       {
33966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33967       };
33968     }
33969   }
33970
33971   jresult = result;
33972   return jresult;
33973 }
33974
33975
33976 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33977   unsigned int jresult ;
33978   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33979   bool result;
33980
33981   arg1 = (Dali::Actor *)jarg1;
33982   {
33983     try {
33984       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33985     } catch (std::out_of_range& e) {
33986       {
33987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33988       };
33989     } catch (std::exception& e) {
33990       {
33991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33992       };
33993     } catch (Dali::DaliException e) {
33994       {
33995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33996       };
33997     } catch (...) {
33998       {
33999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34000       };
34001     }
34002   }
34003
34004   jresult = result;
34005   return jresult;
34006 }
34007
34008
34009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
34010   void * jresult ;
34011   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34012   Dali::Layer result;
34013
34014   arg1 = (Dali::Actor *)jarg1;
34015   {
34016     try {
34017       result = (arg1)->GetLayer();
34018     } catch (std::out_of_range& e) {
34019       {
34020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34021       };
34022     } catch (std::exception& e) {
34023       {
34024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34025       };
34026     } catch (Dali::DaliException e) {
34027       {
34028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34029       };
34030     } catch (...) {
34031       {
34032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34033       };
34034     }
34035   }
34036
34037   jresult = new Dali::Layer((const Dali::Layer &)result);
34038   return jresult;
34039 }
34040
34041
34042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
34043   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34044   Dali::Actor arg2 ;
34045   Dali::Actor *argp2 ;
34046
34047   arg1 = (Dali::Actor *)jarg1;
34048   argp2 = (Dali::Actor *)jarg2;
34049   if (!argp2) {
34050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34051     return ;
34052   }
34053   arg2 = *argp2;
34054   {
34055     try {
34056       (arg1)->Add(arg2);
34057     } catch (std::out_of_range& e) {
34058       {
34059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34060       };
34061     } catch (std::exception& e) {
34062       {
34063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34064       };
34065     } catch (Dali::DaliException e) {
34066       {
34067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34068       };
34069     } catch (...) {
34070       {
34071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34072       };
34073     }
34074   }
34075
34076 }
34077
34078
34079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
34080   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34081   Dali::Actor arg2 ;
34082   Dali::Actor *argp2 ;
34083
34084   arg1 = (Dali::Actor *)jarg1;
34085   argp2 = (Dali::Actor *)jarg2;
34086   if (!argp2) {
34087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34088     return ;
34089   }
34090   arg2 = *argp2;
34091   {
34092     try {
34093       (arg1)->Remove(arg2);
34094     } catch (std::out_of_range& e) {
34095       {
34096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34097       };
34098     } catch (std::exception& e) {
34099       {
34100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34101       };
34102     } catch (Dali::DaliException e) {
34103       {
34104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34105       };
34106     } catch (...) {
34107       {
34108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34109       };
34110     }
34111   }
34112
34113 }
34114
34115
34116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
34117   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34118
34119   arg1 = (Dali::Actor *)jarg1;
34120   {
34121     try {
34122       (arg1)->Unparent();
34123     } catch (std::out_of_range& e) {
34124       {
34125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34126       };
34127     } catch (std::exception& e) {
34128       {
34129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34130       };
34131     } catch (Dali::DaliException e) {
34132       {
34133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34134       };
34135     } catch (...) {
34136       {
34137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34138       };
34139     }
34140   }
34141
34142 }
34143
34144
34145 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
34146   unsigned int jresult ;
34147   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34148   unsigned int result;
34149
34150   arg1 = (Dali::Actor *)jarg1;
34151   {
34152     try {
34153       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
34154     } catch (std::out_of_range& e) {
34155       {
34156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34157       };
34158     } catch (std::exception& e) {
34159       {
34160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34161       };
34162     } catch (Dali::DaliException e) {
34163       {
34164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34165       };
34166     } catch (...) {
34167       {
34168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34169       };
34170     }
34171   }
34172
34173   jresult = result;
34174   return jresult;
34175 }
34176
34177
34178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34179   void * jresult ;
34180   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34181   unsigned int arg2 ;
34182   Dali::Actor result;
34183
34184   arg1 = (Dali::Actor *)jarg1;
34185   arg2 = (unsigned int)jarg2;
34186   {
34187     try {
34188       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34189     } catch (std::out_of_range& e) {
34190       {
34191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34192       };
34193     } catch (std::exception& e) {
34194       {
34195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34196       };
34197     } catch (Dali::DaliException e) {
34198       {
34199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34200       };
34201     } catch (...) {
34202       {
34203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34204       };
34205     }
34206   }
34207
34208   jresult = new Dali::Actor((const Dali::Actor &)result);
34209   return jresult;
34210 }
34211
34212
34213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34214   void * jresult ;
34215   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34216   std::string *arg2 = 0 ;
34217   Dali::Actor result;
34218
34219   arg1 = (Dali::Actor *)jarg1;
34220   if (!jarg2) {
34221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34222     return 0;
34223   }
34224   std::string arg2_str(jarg2);
34225   arg2 = &arg2_str;
34226   {
34227     try {
34228       result = (arg1)->FindChildByName((std::string const &)*arg2);
34229     } catch (std::out_of_range& e) {
34230       {
34231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34232       };
34233     } catch (std::exception& e) {
34234       {
34235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34236       };
34237     } catch (Dali::DaliException e) {
34238       {
34239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34240       };
34241     } catch (...) {
34242       {
34243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34244       };
34245     }
34246   }
34247
34248   jresult = new Dali::Actor((const Dali::Actor &)result);
34249
34250   //argout typemap for const std::string&
34251
34252   return jresult;
34253 }
34254
34255
34256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34257   void * jresult ;
34258   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34259   unsigned int arg2 ;
34260   Dali::Actor result;
34261
34262   arg1 = (Dali::Actor *)jarg1;
34263   arg2 = (unsigned int)jarg2;
34264   {
34265     try {
34266       result = (arg1)->FindChildById(arg2);
34267     } catch (std::out_of_range& e) {
34268       {
34269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34270       };
34271     } catch (std::exception& e) {
34272       {
34273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34274       };
34275     } catch (Dali::DaliException e) {
34276       {
34277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34278       };
34279     } catch (...) {
34280       {
34281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34282       };
34283     }
34284   }
34285
34286   jresult = new Dali::Actor((const Dali::Actor &)result);
34287   return jresult;
34288 }
34289
34290
34291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34292   void * jresult ;
34293   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34294   Dali::Actor result;
34295
34296   arg1 = (Dali::Actor *)jarg1;
34297   {
34298     try {
34299       result = ((Dali::Actor const *)arg1)->GetParent();
34300     } catch (std::out_of_range& e) {
34301       {
34302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34303       };
34304     } catch (std::exception& e) {
34305       {
34306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34307       };
34308     } catch (Dali::DaliException e) {
34309       {
34310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34311       };
34312     } catch (...) {
34313       {
34314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34315       };
34316     }
34317   }
34318
34319   jresult = new Dali::Actor((const Dali::Actor &)result);
34320   return jresult;
34321 }
34322
34323
34324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34325   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34326   Dali::Vector3 *arg2 = 0 ;
34327
34328   arg1 = (Dali::Actor *)jarg1;
34329   arg2 = (Dali::Vector3 *)jarg2;
34330   if (!arg2) {
34331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34332     return ;
34333   }
34334   {
34335     try {
34336       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34337     } catch (std::out_of_range& e) {
34338       {
34339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34340       };
34341     } catch (std::exception& e) {
34342       {
34343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34344       };
34345     } catch (Dali::DaliException e) {
34346       {
34347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34348       };
34349     } catch (...) {
34350       {
34351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34352       };
34353     }
34354   }
34355
34356 }
34357
34358
34359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34360   void * jresult ;
34361   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34362   Dali::Vector3 result;
34363
34364   arg1 = (Dali::Actor *)jarg1;
34365   {
34366     try {
34367       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34368     } catch (std::out_of_range& e) {
34369       {
34370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34371       };
34372     } catch (std::exception& e) {
34373       {
34374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34375       };
34376     } catch (Dali::DaliException e) {
34377       {
34378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34379       };
34380     } catch (...) {
34381       {
34382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34383       };
34384     }
34385   }
34386
34387   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34388   return jresult;
34389 }
34390
34391
34392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34393   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34394   Dali::Vector3 *arg2 = 0 ;
34395
34396   arg1 = (Dali::Actor *)jarg1;
34397   arg2 = (Dali::Vector3 *)jarg2;
34398   if (!arg2) {
34399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34400     return ;
34401   }
34402   {
34403     try {
34404       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34405     } catch (std::out_of_range& e) {
34406       {
34407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34408       };
34409     } catch (std::exception& e) {
34410       {
34411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34412       };
34413     } catch (Dali::DaliException e) {
34414       {
34415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34416       };
34417     } catch (...) {
34418       {
34419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34420       };
34421     }
34422   }
34423
34424 }
34425
34426
34427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34428   void * jresult ;
34429   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34430   Dali::Vector3 result;
34431
34432   arg1 = (Dali::Actor *)jarg1;
34433   {
34434     try {
34435       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34436     } catch (std::out_of_range& e) {
34437       {
34438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34439       };
34440     } catch (std::exception& e) {
34441       {
34442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34443       };
34444     } catch (Dali::DaliException e) {
34445       {
34446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34447       };
34448     } catch (...) {
34449       {
34450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34451       };
34452     }
34453   }
34454
34455   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34456   return jresult;
34457 }
34458
34459
34460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34461   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34462   float arg2 ;
34463   float arg3 ;
34464
34465   arg1 = (Dali::Actor *)jarg1;
34466   arg2 = (float)jarg2;
34467   arg3 = (float)jarg3;
34468   {
34469     try {
34470       (arg1)->SetSize(arg2,arg3);
34471     } catch (std::out_of_range& e) {
34472       {
34473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34474       };
34475     } catch (std::exception& e) {
34476       {
34477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34478       };
34479     } catch (Dali::DaliException e) {
34480       {
34481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34482       };
34483     } catch (...) {
34484       {
34485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34486       };
34487     }
34488   }
34489
34490 }
34491
34492
34493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34494   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34495   float arg2 ;
34496   float arg3 ;
34497   float arg4 ;
34498
34499   arg1 = (Dali::Actor *)jarg1;
34500   arg2 = (float)jarg2;
34501   arg3 = (float)jarg3;
34502   arg4 = (float)jarg4;
34503   {
34504     try {
34505       (arg1)->SetSize(arg2,arg3,arg4);
34506     } catch (std::out_of_range& e) {
34507       {
34508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34509       };
34510     } catch (std::exception& e) {
34511       {
34512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34513       };
34514     } catch (Dali::DaliException e) {
34515       {
34516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34517       };
34518     } catch (...) {
34519       {
34520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34521       };
34522     }
34523   }
34524
34525 }
34526
34527
34528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34529   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34530   Dali::Vector2 *arg2 = 0 ;
34531
34532   arg1 = (Dali::Actor *)jarg1;
34533   arg2 = (Dali::Vector2 *)jarg2;
34534   if (!arg2) {
34535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34536     return ;
34537   }
34538   {
34539     try {
34540       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34541     } catch (std::out_of_range& e) {
34542       {
34543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34544       };
34545     } catch (std::exception& e) {
34546       {
34547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34548       };
34549     } catch (Dali::DaliException e) {
34550       {
34551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34552       };
34553     } catch (...) {
34554       {
34555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34556       };
34557     }
34558   }
34559
34560 }
34561
34562
34563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34564   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34565   Dali::Vector3 *arg2 = 0 ;
34566
34567   arg1 = (Dali::Actor *)jarg1;
34568   arg2 = (Dali::Vector3 *)jarg2;
34569   if (!arg2) {
34570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34571     return ;
34572   }
34573   {
34574     try {
34575       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34576     } catch (std::out_of_range& e) {
34577       {
34578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34579       };
34580     } catch (std::exception& e) {
34581       {
34582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34583       };
34584     } catch (Dali::DaliException e) {
34585       {
34586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34587       };
34588     } catch (...) {
34589       {
34590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34591       };
34592     }
34593   }
34594
34595 }
34596
34597
34598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34599   void * jresult ;
34600   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34601   Dali::Vector3 result;
34602
34603   arg1 = (Dali::Actor *)jarg1;
34604   {
34605     try {
34606       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34607     } catch (std::out_of_range& e) {
34608       {
34609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34610       };
34611     } catch (std::exception& e) {
34612       {
34613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34614       };
34615     } catch (Dali::DaliException e) {
34616       {
34617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34618       };
34619     } catch (...) {
34620       {
34621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34622       };
34623     }
34624   }
34625
34626   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34627   return jresult;
34628 }
34629
34630
34631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34632   void * jresult ;
34633   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34634   Dali::Vector3 result;
34635
34636   arg1 = (Dali::Actor *)jarg1;
34637   {
34638     try {
34639       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34640     } catch (std::out_of_range& e) {
34641       {
34642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34643       };
34644     } catch (std::exception& e) {
34645       {
34646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34647       };
34648     } catch (Dali::DaliException e) {
34649       {
34650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34651       };
34652     } catch (...) {
34653       {
34654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34655       };
34656     }
34657   }
34658
34659   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34660   return jresult;
34661 }
34662
34663
34664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34665   void * jresult ;
34666   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34667   Dali::Vector3 result;
34668
34669   arg1 = (Dali::Actor *)jarg1;
34670   {
34671     try {
34672       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34673     } catch (std::out_of_range& e) {
34674       {
34675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34676       };
34677     } catch (std::exception& e) {
34678       {
34679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34680       };
34681     } catch (Dali::DaliException e) {
34682       {
34683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34684       };
34685     } catch (...) {
34686       {
34687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34688       };
34689     }
34690   }
34691
34692   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34693   return jresult;
34694 }
34695
34696
34697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34698   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34699   float arg2 ;
34700   float arg3 ;
34701
34702   arg1 = (Dali::Actor *)jarg1;
34703   arg2 = (float)jarg2;
34704   arg3 = (float)jarg3;
34705   {
34706     try {
34707       (arg1)->SetPosition(arg2,arg3);
34708     } catch (std::out_of_range& e) {
34709       {
34710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34711       };
34712     } catch (std::exception& e) {
34713       {
34714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34715       };
34716     } catch (Dali::DaliException e) {
34717       {
34718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34719       };
34720     } catch (...) {
34721       {
34722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34723       };
34724     }
34725   }
34726
34727 }
34728
34729
34730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34731   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34732   float arg2 ;
34733   float arg3 ;
34734   float arg4 ;
34735
34736   arg1 = (Dali::Actor *)jarg1;
34737   arg2 = (float)jarg2;
34738   arg3 = (float)jarg3;
34739   arg4 = (float)jarg4;
34740   {
34741     try {
34742       (arg1)->SetPosition(arg2,arg3,arg4);
34743     } catch (std::out_of_range& e) {
34744       {
34745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34746       };
34747     } catch (std::exception& e) {
34748       {
34749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34750       };
34751     } catch (Dali::DaliException e) {
34752       {
34753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34754       };
34755     } catch (...) {
34756       {
34757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34758       };
34759     }
34760   }
34761
34762 }
34763
34764
34765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34766   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34767   Dali::Vector3 *arg2 = 0 ;
34768
34769   arg1 = (Dali::Actor *)jarg1;
34770   arg2 = (Dali::Vector3 *)jarg2;
34771   if (!arg2) {
34772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34773     return ;
34774   }
34775   {
34776     try {
34777       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34778     } catch (std::out_of_range& e) {
34779       {
34780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34781       };
34782     } catch (std::exception& e) {
34783       {
34784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34785       };
34786     } catch (Dali::DaliException e) {
34787       {
34788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34789       };
34790     } catch (...) {
34791       {
34792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34793       };
34794     }
34795   }
34796
34797 }
34798
34799
34800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34801   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34802   float arg2 ;
34803
34804   arg1 = (Dali::Actor *)jarg1;
34805   arg2 = (float)jarg2;
34806   {
34807     try {
34808       (arg1)->SetX(arg2);
34809     } catch (std::out_of_range& e) {
34810       {
34811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34812       };
34813     } catch (std::exception& e) {
34814       {
34815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34816       };
34817     } catch (Dali::DaliException e) {
34818       {
34819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34820       };
34821     } catch (...) {
34822       {
34823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34824       };
34825     }
34826   }
34827
34828 }
34829
34830
34831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34832   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34833   float arg2 ;
34834
34835   arg1 = (Dali::Actor *)jarg1;
34836   arg2 = (float)jarg2;
34837   {
34838     try {
34839       (arg1)->SetY(arg2);
34840     } catch (std::out_of_range& e) {
34841       {
34842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34843       };
34844     } catch (std::exception& e) {
34845       {
34846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34847       };
34848     } catch (Dali::DaliException e) {
34849       {
34850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34851       };
34852     } catch (...) {
34853       {
34854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34855       };
34856     }
34857   }
34858
34859 }
34860
34861
34862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34863   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34864   float arg2 ;
34865
34866   arg1 = (Dali::Actor *)jarg1;
34867   arg2 = (float)jarg2;
34868   {
34869     try {
34870       (arg1)->SetZ(arg2);
34871     } catch (std::out_of_range& e) {
34872       {
34873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34874       };
34875     } catch (std::exception& e) {
34876       {
34877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34878       };
34879     } catch (Dali::DaliException e) {
34880       {
34881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34882       };
34883     } catch (...) {
34884       {
34885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34886       };
34887     }
34888   }
34889
34890 }
34891
34892
34893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34894   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34895   Dali::Vector3 *arg2 = 0 ;
34896
34897   arg1 = (Dali::Actor *)jarg1;
34898   arg2 = (Dali::Vector3 *)jarg2;
34899   if (!arg2) {
34900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34901     return ;
34902   }
34903   {
34904     try {
34905       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34906     } catch (std::out_of_range& e) {
34907       {
34908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34909       };
34910     } catch (std::exception& e) {
34911       {
34912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34913       };
34914     } catch (Dali::DaliException e) {
34915       {
34916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34917       };
34918     } catch (...) {
34919       {
34920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34921       };
34922     }
34923   }
34924
34925 }
34926
34927
34928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34929   void * jresult ;
34930   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34931   Dali::Vector3 result;
34932
34933   arg1 = (Dali::Actor *)jarg1;
34934   {
34935     try {
34936       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34937     } catch (std::out_of_range& e) {
34938       {
34939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34940       };
34941     } catch (std::exception& e) {
34942       {
34943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34944       };
34945     } catch (Dali::DaliException e) {
34946       {
34947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34948       };
34949     } catch (...) {
34950       {
34951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34952       };
34953     }
34954   }
34955
34956   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34957   return jresult;
34958 }
34959
34960
34961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34962   void * jresult ;
34963   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34964   Dali::Vector3 result;
34965
34966   arg1 = (Dali::Actor *)jarg1;
34967   {
34968     try {
34969       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34970     } catch (std::out_of_range& e) {
34971       {
34972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34973       };
34974     } catch (std::exception& e) {
34975       {
34976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34977       };
34978     } catch (Dali::DaliException e) {
34979       {
34980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34981       };
34982     } catch (...) {
34983       {
34984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34985       };
34986     }
34987   }
34988
34989   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34990   return jresult;
34991 }
34992
34993
34994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34995   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34996   bool arg2 ;
34997
34998   arg1 = (Dali::Actor *)jarg1;
34999   arg2 = jarg2 ? true : false;
35000   {
35001     try {
35002       (arg1)->SetInheritPosition(arg2);
35003     } catch (std::out_of_range& e) {
35004       {
35005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35006       };
35007     } catch (std::exception& e) {
35008       {
35009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35010       };
35011     } catch (Dali::DaliException e) {
35012       {
35013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35014       };
35015     } catch (...) {
35016       {
35017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35018       };
35019     }
35020   }
35021
35022 }
35023
35024
35025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
35026   unsigned int jresult ;
35027   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35028   bool result;
35029
35030   arg1 = (Dali::Actor *)jarg1;
35031   {
35032     try {
35033       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
35034     } catch (std::out_of_range& e) {
35035       {
35036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35037       };
35038     } catch (std::exception& e) {
35039       {
35040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35041       };
35042     } catch (Dali::DaliException e) {
35043       {
35044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35045       };
35046     } catch (...) {
35047       {
35048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35049       };
35050     }
35051   }
35052
35053   jresult = result;
35054   return jresult;
35055 }
35056
35057
35058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35059   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35060   Dali::Degree *arg2 = 0 ;
35061   Dali::Vector3 *arg3 = 0 ;
35062
35063   arg1 = (Dali::Actor *)jarg1;
35064   arg2 = (Dali::Degree *)jarg2;
35065   if (!arg2) {
35066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35067     return ;
35068   }
35069   arg3 = (Dali::Vector3 *)jarg3;
35070   if (!arg3) {
35071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35072     return ;
35073   }
35074   {
35075     try {
35076       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35077     } catch (std::out_of_range& e) {
35078       {
35079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35080       };
35081     } catch (std::exception& e) {
35082       {
35083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35084       };
35085     } catch (Dali::DaliException e) {
35086       {
35087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35088       };
35089     } catch (...) {
35090       {
35091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35092       };
35093     }
35094   }
35095
35096 }
35097
35098
35099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35100   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35101   Dali::Radian *arg2 = 0 ;
35102   Dali::Vector3 *arg3 = 0 ;
35103
35104   arg1 = (Dali::Actor *)jarg1;
35105   arg2 = (Dali::Radian *)jarg2;
35106   if (!arg2) {
35107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35108     return ;
35109   }
35110   arg3 = (Dali::Vector3 *)jarg3;
35111   if (!arg3) {
35112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35113     return ;
35114   }
35115   {
35116     try {
35117       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35118     } catch (std::out_of_range& e) {
35119       {
35120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35121       };
35122     } catch (std::exception& e) {
35123       {
35124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35125       };
35126     } catch (Dali::DaliException e) {
35127       {
35128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35129       };
35130     } catch (...) {
35131       {
35132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35133       };
35134     }
35135   }
35136
35137 }
35138
35139
35140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35141   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35142   Dali::Quaternion *arg2 = 0 ;
35143
35144   arg1 = (Dali::Actor *)jarg1;
35145   arg2 = (Dali::Quaternion *)jarg2;
35146   if (!arg2) {
35147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35148     return ;
35149   }
35150   {
35151     try {
35152       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
35153     } catch (std::out_of_range& e) {
35154       {
35155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35156       };
35157     } catch (std::exception& e) {
35158       {
35159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35160       };
35161     } catch (Dali::DaliException e) {
35162       {
35163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35164       };
35165     } catch (...) {
35166       {
35167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35168       };
35169     }
35170   }
35171
35172 }
35173
35174
35175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35176   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35177   Dali::Degree *arg2 = 0 ;
35178   Dali::Vector3 *arg3 = 0 ;
35179
35180   arg1 = (Dali::Actor *)jarg1;
35181   arg2 = (Dali::Degree *)jarg2;
35182   if (!arg2) {
35183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35184     return ;
35185   }
35186   arg3 = (Dali::Vector3 *)jarg3;
35187   if (!arg3) {
35188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35189     return ;
35190   }
35191   {
35192     try {
35193       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35194     } catch (std::out_of_range& e) {
35195       {
35196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35197       };
35198     } catch (std::exception& e) {
35199       {
35200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35201       };
35202     } catch (Dali::DaliException e) {
35203       {
35204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35205       };
35206     } catch (...) {
35207       {
35208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35209       };
35210     }
35211   }
35212
35213 }
35214
35215
35216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35217   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35218   Dali::Radian *arg2 = 0 ;
35219   Dali::Vector3 *arg3 = 0 ;
35220
35221   arg1 = (Dali::Actor *)jarg1;
35222   arg2 = (Dali::Radian *)jarg2;
35223   if (!arg2) {
35224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35225     return ;
35226   }
35227   arg3 = (Dali::Vector3 *)jarg3;
35228   if (!arg3) {
35229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35230     return ;
35231   }
35232   {
35233     try {
35234       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35235     } catch (std::out_of_range& e) {
35236       {
35237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35238       };
35239     } catch (std::exception& e) {
35240       {
35241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35242       };
35243     } catch (Dali::DaliException e) {
35244       {
35245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35246       };
35247     } catch (...) {
35248       {
35249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35250       };
35251     }
35252   }
35253
35254 }
35255
35256
35257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35258   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35259   Dali::Quaternion *arg2 = 0 ;
35260
35261   arg1 = (Dali::Actor *)jarg1;
35262   arg2 = (Dali::Quaternion *)jarg2;
35263   if (!arg2) {
35264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35265     return ;
35266   }
35267   {
35268     try {
35269       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35270     } catch (std::out_of_range& e) {
35271       {
35272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35273       };
35274     } catch (std::exception& e) {
35275       {
35276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35277       };
35278     } catch (Dali::DaliException e) {
35279       {
35280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35281       };
35282     } catch (...) {
35283       {
35284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35285       };
35286     }
35287   }
35288
35289 }
35290
35291
35292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35293   void * jresult ;
35294   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35295   Dali::Quaternion result;
35296
35297   arg1 = (Dali::Actor *)jarg1;
35298   {
35299     try {
35300       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35301     } catch (std::out_of_range& e) {
35302       {
35303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35304       };
35305     } catch (std::exception& e) {
35306       {
35307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35308       };
35309     } catch (Dali::DaliException e) {
35310       {
35311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35312       };
35313     } catch (...) {
35314       {
35315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35316       };
35317     }
35318   }
35319
35320   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35321   return jresult;
35322 }
35323
35324
35325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35326   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35327   bool arg2 ;
35328
35329   arg1 = (Dali::Actor *)jarg1;
35330   arg2 = jarg2 ? true : false;
35331   {
35332     try {
35333       (arg1)->SetInheritOrientation(arg2);
35334     } catch (std::out_of_range& e) {
35335       {
35336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35337       };
35338     } catch (std::exception& e) {
35339       {
35340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35341       };
35342     } catch (Dali::DaliException e) {
35343       {
35344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35345       };
35346     } catch (...) {
35347       {
35348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35349       };
35350     }
35351   }
35352
35353 }
35354
35355
35356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35357   unsigned int jresult ;
35358   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35359   bool result;
35360
35361   arg1 = (Dali::Actor *)jarg1;
35362   {
35363     try {
35364       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35365     } catch (std::out_of_range& e) {
35366       {
35367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35368       };
35369     } catch (std::exception& e) {
35370       {
35371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35372       };
35373     } catch (Dali::DaliException e) {
35374       {
35375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35376       };
35377     } catch (...) {
35378       {
35379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35380       };
35381     }
35382   }
35383
35384   jresult = result;
35385   return jresult;
35386 }
35387
35388
35389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35390   void * jresult ;
35391   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35392   Dali::Quaternion result;
35393
35394   arg1 = (Dali::Actor *)jarg1;
35395   {
35396     try {
35397       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35398     } catch (std::out_of_range& e) {
35399       {
35400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35401       };
35402     } catch (std::exception& e) {
35403       {
35404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35405       };
35406     } catch (Dali::DaliException e) {
35407       {
35408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35409       };
35410     } catch (...) {
35411       {
35412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35413       };
35414     }
35415   }
35416
35417   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35418   return jresult;
35419 }
35420
35421
35422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35423   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35424   float arg2 ;
35425
35426   arg1 = (Dali::Actor *)jarg1;
35427   arg2 = (float)jarg2;
35428   {
35429     try {
35430       (arg1)->SetScale(arg2);
35431     } catch (std::out_of_range& e) {
35432       {
35433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35434       };
35435     } catch (std::exception& e) {
35436       {
35437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35438       };
35439     } catch (Dali::DaliException e) {
35440       {
35441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35442       };
35443     } catch (...) {
35444       {
35445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35446       };
35447     }
35448   }
35449
35450 }
35451
35452
35453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35454   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35455   float arg2 ;
35456   float arg3 ;
35457   float arg4 ;
35458
35459   arg1 = (Dali::Actor *)jarg1;
35460   arg2 = (float)jarg2;
35461   arg3 = (float)jarg3;
35462   arg4 = (float)jarg4;
35463   {
35464     try {
35465       (arg1)->SetScale(arg2,arg3,arg4);
35466     } catch (std::out_of_range& e) {
35467       {
35468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35469       };
35470     } catch (std::exception& e) {
35471       {
35472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35473       };
35474     } catch (Dali::DaliException e) {
35475       {
35476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35477       };
35478     } catch (...) {
35479       {
35480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35481       };
35482     }
35483   }
35484
35485 }
35486
35487
35488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35489   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35490   Dali::Vector3 *arg2 = 0 ;
35491
35492   arg1 = (Dali::Actor *)jarg1;
35493   arg2 = (Dali::Vector3 *)jarg2;
35494   if (!arg2) {
35495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35496     return ;
35497   }
35498   {
35499     try {
35500       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35501     } catch (std::out_of_range& e) {
35502       {
35503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35504       };
35505     } catch (std::exception& e) {
35506       {
35507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35508       };
35509     } catch (Dali::DaliException e) {
35510       {
35511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35512       };
35513     } catch (...) {
35514       {
35515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35516       };
35517     }
35518   }
35519
35520 }
35521
35522
35523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35524   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35525   Dali::Vector3 *arg2 = 0 ;
35526
35527   arg1 = (Dali::Actor *)jarg1;
35528   arg2 = (Dali::Vector3 *)jarg2;
35529   if (!arg2) {
35530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35531     return ;
35532   }
35533   {
35534     try {
35535       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35536     } catch (std::out_of_range& e) {
35537       {
35538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35539       };
35540     } catch (std::exception& e) {
35541       {
35542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35543       };
35544     } catch (Dali::DaliException e) {
35545       {
35546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35547       };
35548     } catch (...) {
35549       {
35550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35551       };
35552     }
35553   }
35554
35555 }
35556
35557
35558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35559   void * jresult ;
35560   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35561   Dali::Vector3 result;
35562
35563   arg1 = (Dali::Actor *)jarg1;
35564   {
35565     try {
35566       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35567     } catch (std::out_of_range& e) {
35568       {
35569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35570       };
35571     } catch (std::exception& e) {
35572       {
35573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35574       };
35575     } catch (Dali::DaliException e) {
35576       {
35577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35578       };
35579     } catch (...) {
35580       {
35581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35582       };
35583     }
35584   }
35585
35586   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35587   return jresult;
35588 }
35589
35590
35591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35592   void * jresult ;
35593   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35594   Dali::Vector3 result;
35595
35596   arg1 = (Dali::Actor *)jarg1;
35597   {
35598     try {
35599       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35600     } catch (std::out_of_range& e) {
35601       {
35602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35603       };
35604     } catch (std::exception& e) {
35605       {
35606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35607       };
35608     } catch (Dali::DaliException e) {
35609       {
35610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35611       };
35612     } catch (...) {
35613       {
35614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35615       };
35616     }
35617   }
35618
35619   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35620   return jresult;
35621 }
35622
35623
35624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35625   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35626   bool arg2 ;
35627
35628   arg1 = (Dali::Actor *)jarg1;
35629   arg2 = jarg2 ? true : false;
35630   {
35631     try {
35632       (arg1)->SetInheritScale(arg2);
35633     } catch (std::out_of_range& e) {
35634       {
35635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35636       };
35637     } catch (std::exception& e) {
35638       {
35639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35640       };
35641     } catch (Dali::DaliException e) {
35642       {
35643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35644       };
35645     } catch (...) {
35646       {
35647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35648       };
35649     }
35650   }
35651
35652 }
35653
35654
35655 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35656   unsigned int jresult ;
35657   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35658   bool result;
35659
35660   arg1 = (Dali::Actor *)jarg1;
35661   {
35662     try {
35663       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35664     } catch (std::out_of_range& e) {
35665       {
35666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35667       };
35668     } catch (std::exception& e) {
35669       {
35670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35671       };
35672     } catch (Dali::DaliException e) {
35673       {
35674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35675       };
35676     } catch (...) {
35677       {
35678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35679       };
35680     }
35681   }
35682
35683   jresult = result;
35684   return jresult;
35685 }
35686
35687
35688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35689   void * jresult ;
35690   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35691   Dali::Matrix result;
35692
35693   arg1 = (Dali::Actor *)jarg1;
35694   {
35695     try {
35696       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35697     } catch (std::out_of_range& e) {
35698       {
35699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35700       };
35701     } catch (std::exception& e) {
35702       {
35703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35704       };
35705     } catch (Dali::DaliException e) {
35706       {
35707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35708       };
35709     } catch (...) {
35710       {
35711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35712       };
35713     }
35714   }
35715
35716   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35717   return jresult;
35718 }
35719
35720
35721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35722   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35723   bool arg2 ;
35724
35725   arg1 = (Dali::Actor *)jarg1;
35726   arg2 = jarg2 ? true : false;
35727   {
35728     try {
35729       (arg1)->SetVisible(arg2);
35730     } catch (std::out_of_range& e) {
35731       {
35732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35733       };
35734     } catch (std::exception& e) {
35735       {
35736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35737       };
35738     } catch (Dali::DaliException e) {
35739       {
35740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35741       };
35742     } catch (...) {
35743       {
35744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35745       };
35746     }
35747   }
35748
35749 }
35750
35751
35752 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35753   unsigned int jresult ;
35754   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35755   bool result;
35756
35757   arg1 = (Dali::Actor *)jarg1;
35758   {
35759     try {
35760       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35761     } catch (std::out_of_range& e) {
35762       {
35763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35764       };
35765     } catch (std::exception& e) {
35766       {
35767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35768       };
35769     } catch (Dali::DaliException e) {
35770       {
35771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35772       };
35773     } catch (...) {
35774       {
35775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35776       };
35777     }
35778   }
35779
35780   jresult = result;
35781   return jresult;
35782 }
35783
35784
35785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35786   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35787   float arg2 ;
35788
35789   arg1 = (Dali::Actor *)jarg1;
35790   arg2 = (float)jarg2;
35791   {
35792     try {
35793       (arg1)->SetOpacity(arg2);
35794     } catch (std::out_of_range& e) {
35795       {
35796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35797       };
35798     } catch (std::exception& e) {
35799       {
35800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35801       };
35802     } catch (Dali::DaliException e) {
35803       {
35804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35805       };
35806     } catch (...) {
35807       {
35808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35809       };
35810     }
35811   }
35812
35813 }
35814
35815
35816 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35817   float jresult ;
35818   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35819   float result;
35820
35821   arg1 = (Dali::Actor *)jarg1;
35822   {
35823     try {
35824       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35825     } catch (std::out_of_range& e) {
35826       {
35827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35828       };
35829     } catch (std::exception& e) {
35830       {
35831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35832       };
35833     } catch (Dali::DaliException e) {
35834       {
35835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35836       };
35837     } catch (...) {
35838       {
35839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35840       };
35841     }
35842   }
35843
35844   jresult = result;
35845   return jresult;
35846 }
35847
35848
35849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35850   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35851   Dali::Vector4 *arg2 = 0 ;
35852
35853   arg1 = (Dali::Actor *)jarg1;
35854   arg2 = (Dali::Vector4 *)jarg2;
35855   if (!arg2) {
35856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35857     return ;
35858   }
35859   {
35860     try {
35861       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35862     } catch (std::out_of_range& e) {
35863       {
35864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35865       };
35866     } catch (std::exception& e) {
35867       {
35868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35869       };
35870     } catch (Dali::DaliException e) {
35871       {
35872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35873       };
35874     } catch (...) {
35875       {
35876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35877       };
35878     }
35879   }
35880
35881 }
35882
35883
35884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35885   void * jresult ;
35886   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35887   Dali::Vector4 result;
35888
35889   arg1 = (Dali::Actor *)jarg1;
35890   {
35891     try {
35892       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35893     } catch (std::out_of_range& e) {
35894       {
35895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35896       };
35897     } catch (std::exception& e) {
35898       {
35899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35900       };
35901     } catch (Dali::DaliException e) {
35902       {
35903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35904       };
35905     } catch (...) {
35906       {
35907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35908       };
35909     }
35910   }
35911
35912   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35913   return jresult;
35914 }
35915
35916
35917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35918   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35919   Dali::ColorMode arg2 ;
35920
35921   arg1 = (Dali::Actor *)jarg1;
35922   arg2 = (Dali::ColorMode)jarg2;
35923   {
35924     try {
35925       (arg1)->SetColorMode(arg2);
35926     } catch (std::out_of_range& e) {
35927       {
35928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35929       };
35930     } catch (std::exception& e) {
35931       {
35932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35933       };
35934     } catch (Dali::DaliException e) {
35935       {
35936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35937       };
35938     } catch (...) {
35939       {
35940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35941       };
35942     }
35943   }
35944
35945 }
35946
35947
35948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35949   int jresult ;
35950   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35951   Dali::ColorMode result;
35952
35953   arg1 = (Dali::Actor *)jarg1;
35954   {
35955     try {
35956       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35957     } catch (std::out_of_range& e) {
35958       {
35959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35960       };
35961     } catch (std::exception& e) {
35962       {
35963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35964       };
35965     } catch (Dali::DaliException e) {
35966       {
35967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35968       };
35969     } catch (...) {
35970       {
35971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35972       };
35973     }
35974   }
35975
35976   jresult = (int)result;
35977   return jresult;
35978 }
35979
35980
35981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35982   void * jresult ;
35983   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35984   Dali::Vector4 result;
35985
35986   arg1 = (Dali::Actor *)jarg1;
35987   {
35988     try {
35989       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35990     } catch (std::out_of_range& e) {
35991       {
35992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35993       };
35994     } catch (std::exception& e) {
35995       {
35996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35997       };
35998     } catch (Dali::DaliException e) {
35999       {
36000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36001       };
36002     } catch (...) {
36003       {
36004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36005       };
36006     }
36007   }
36008
36009   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
36010   return jresult;
36011 }
36012
36013
36014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
36015   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36016   Dali::DrawMode::Type arg2 ;
36017
36018   arg1 = (Dali::Actor *)jarg1;
36019   arg2 = (Dali::DrawMode::Type)jarg2;
36020   {
36021     try {
36022       (arg1)->SetDrawMode(arg2);
36023     } catch (std::out_of_range& e) {
36024       {
36025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36026       };
36027     } catch (std::exception& e) {
36028       {
36029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36030       };
36031     } catch (Dali::DaliException e) {
36032       {
36033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36034       };
36035     } catch (...) {
36036       {
36037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36038       };
36039     }
36040   }
36041
36042 }
36043
36044
36045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
36046   int jresult ;
36047   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36048   Dali::DrawMode::Type result;
36049
36050   arg1 = (Dali::Actor *)jarg1;
36051   {
36052     try {
36053       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
36054     } catch (std::out_of_range& e) {
36055       {
36056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36057       };
36058     } catch (std::exception& e) {
36059       {
36060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36061       };
36062     } catch (Dali::DaliException e) {
36063       {
36064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36065       };
36066     } catch (...) {
36067       {
36068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36069       };
36070     }
36071   }
36072
36073   jresult = (int)result;
36074   return jresult;
36075 }
36076
36077
36078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
36079   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36080   bool arg2 ;
36081
36082   arg1 = (Dali::Actor *)jarg1;
36083   arg2 = jarg2 ? true : false;
36084   {
36085     try {
36086       (arg1)->SetSensitive(arg2);
36087     } catch (std::out_of_range& e) {
36088       {
36089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36090       };
36091     } catch (std::exception& e) {
36092       {
36093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36094       };
36095     } catch (Dali::DaliException e) {
36096       {
36097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36098       };
36099     } catch (...) {
36100       {
36101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36102       };
36103     }
36104   }
36105
36106 }
36107
36108
36109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
36110   unsigned int jresult ;
36111   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36112   bool result;
36113
36114   arg1 = (Dali::Actor *)jarg1;
36115   {
36116     try {
36117       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
36118     } catch (std::out_of_range& e) {
36119       {
36120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36121       };
36122     } catch (std::exception& e) {
36123       {
36124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36125       };
36126     } catch (Dali::DaliException e) {
36127       {
36128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36129       };
36130     } catch (...) {
36131       {
36132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36133       };
36134     }
36135   }
36136
36137   jresult = result;
36138   return jresult;
36139 }
36140
36141
36142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36143   unsigned int jresult ;
36144   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36145   float *arg2 = 0 ;
36146   float *arg3 = 0 ;
36147   float arg4 ;
36148   float arg5 ;
36149   bool result;
36150
36151   arg1 = (Dali::Actor *)jarg1;
36152   arg2 = (float *)jarg2;
36153   arg3 = (float *)jarg3;
36154   arg4 = (float)jarg4;
36155   arg5 = (float)jarg5;
36156   {
36157     try {
36158       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36159     } catch (std::out_of_range& e) {
36160       {
36161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36162       };
36163     } catch (std::exception& e) {
36164       {
36165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36166       };
36167     } catch (Dali::DaliException e) {
36168       {
36169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36170       };
36171     } catch (...) {
36172       {
36173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36174       };
36175     }
36176   }
36177
36178   jresult = result;
36179   return jresult;
36180 }
36181
36182
36183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36184   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36185   bool arg2 ;
36186
36187   arg1 = (Dali::Actor *)jarg1;
36188   arg2 = jarg2 ? true : false;
36189   {
36190     try {
36191       (arg1)->SetLeaveRequired(arg2);
36192     } catch (std::out_of_range& e) {
36193       {
36194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36195       };
36196     } catch (std::exception& e) {
36197       {
36198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36199       };
36200     } catch (Dali::DaliException e) {
36201       {
36202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36203       };
36204     } catch (...) {
36205       {
36206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36207       };
36208     }
36209   }
36210
36211 }
36212
36213
36214 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36215   unsigned int jresult ;
36216   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36217   bool result;
36218
36219   arg1 = (Dali::Actor *)jarg1;
36220   {
36221     try {
36222       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
36223     } catch (std::out_of_range& e) {
36224       {
36225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36226       };
36227     } catch (std::exception& e) {
36228       {
36229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36230       };
36231     } catch (Dali::DaliException e) {
36232       {
36233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36234       };
36235     } catch (...) {
36236       {
36237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36238       };
36239     }
36240   }
36241
36242   jresult = result;
36243   return jresult;
36244 }
36245
36246
36247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36248   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36249   bool arg2 ;
36250
36251   arg1 = (Dali::Actor *)jarg1;
36252   arg2 = jarg2 ? true : false;
36253   {
36254     try {
36255       (arg1)->SetKeyboardFocusable(arg2);
36256     } catch (std::out_of_range& e) {
36257       {
36258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36259       };
36260     } catch (std::exception& e) {
36261       {
36262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36263       };
36264     } catch (Dali::DaliException e) {
36265       {
36266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36267       };
36268     } catch (...) {
36269       {
36270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36271       };
36272     }
36273   }
36274
36275 }
36276
36277
36278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36279   unsigned int jresult ;
36280   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36281   bool result;
36282
36283   arg1 = (Dali::Actor *)jarg1;
36284   {
36285     try {
36286       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36287     } catch (std::out_of_range& e) {
36288       {
36289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36290       };
36291     } catch (std::exception& e) {
36292       {
36293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36294       };
36295     } catch (Dali::DaliException e) {
36296       {
36297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36298       };
36299     } catch (...) {
36300       {
36301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36302       };
36303     }
36304   }
36305
36306   jresult = result;
36307   return jresult;
36308 }
36309
36310
36311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36312   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36313   Dali::ResizePolicy::Type arg2 ;
36314   Dali::Dimension::Type arg3 ;
36315
36316   arg1 = (Dali::Actor *)jarg1;
36317   arg2 = (Dali::ResizePolicy::Type)jarg2;
36318   arg3 = (Dali::Dimension::Type)jarg3;
36319   {
36320     try {
36321       (arg1)->SetResizePolicy(arg2,arg3);
36322     } catch (std::out_of_range& e) {
36323       {
36324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36325       };
36326     } catch (std::exception& e) {
36327       {
36328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36329       };
36330     } catch (Dali::DaliException e) {
36331       {
36332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36333       };
36334     } catch (...) {
36335       {
36336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36337       };
36338     }
36339   }
36340
36341 }
36342
36343
36344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36345   int jresult ;
36346   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36347   Dali::Dimension::Type arg2 ;
36348   Dali::ResizePolicy::Type result;
36349
36350   arg1 = (Dali::Actor *)jarg1;
36351   arg2 = (Dali::Dimension::Type)jarg2;
36352   {
36353     try {
36354       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36355     } catch (std::out_of_range& e) {
36356       {
36357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36358       };
36359     } catch (std::exception& e) {
36360       {
36361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36362       };
36363     } catch (Dali::DaliException e) {
36364       {
36365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36366       };
36367     } catch (...) {
36368       {
36369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36370       };
36371     }
36372   }
36373
36374   jresult = (int)result;
36375   return jresult;
36376 }
36377
36378
36379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36380   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36381   Dali::SizeScalePolicy::Type arg2 ;
36382
36383   arg1 = (Dali::Actor *)jarg1;
36384   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36385   {
36386     try {
36387       (arg1)->SetSizeScalePolicy(arg2);
36388     } catch (std::out_of_range& e) {
36389       {
36390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36391       };
36392     } catch (std::exception& e) {
36393       {
36394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36395       };
36396     } catch (Dali::DaliException e) {
36397       {
36398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36399       };
36400     } catch (...) {
36401       {
36402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36403       };
36404     }
36405   }
36406
36407 }
36408
36409
36410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36411   int jresult ;
36412   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36413   Dali::SizeScalePolicy::Type result;
36414
36415   arg1 = (Dali::Actor *)jarg1;
36416   {
36417     try {
36418       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36419     } catch (std::out_of_range& e) {
36420       {
36421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36422       };
36423     } catch (std::exception& e) {
36424       {
36425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36426       };
36427     } catch (Dali::DaliException e) {
36428       {
36429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36430       };
36431     } catch (...) {
36432       {
36433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36434       };
36435     }
36436   }
36437
36438   jresult = (int)result;
36439   return jresult;
36440 }
36441
36442
36443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36444   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36445   Dali::Vector3 *arg2 = 0 ;
36446
36447   arg1 = (Dali::Actor *)jarg1;
36448   arg2 = (Dali::Vector3 *)jarg2;
36449   if (!arg2) {
36450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36451     return ;
36452   }
36453   {
36454     try {
36455       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36456     } catch (std::out_of_range& e) {
36457       {
36458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36459       };
36460     } catch (std::exception& e) {
36461       {
36462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36463       };
36464     } catch (Dali::DaliException e) {
36465       {
36466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36467       };
36468     } catch (...) {
36469       {
36470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36471       };
36472     }
36473   }
36474
36475 }
36476
36477
36478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36479   void * jresult ;
36480   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36481   Dali::Vector3 result;
36482
36483   arg1 = (Dali::Actor *)jarg1;
36484   {
36485     try {
36486       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36487     } catch (std::out_of_range& e) {
36488       {
36489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36490       };
36491     } catch (std::exception& e) {
36492       {
36493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36494       };
36495     } catch (Dali::DaliException e) {
36496       {
36497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36498       };
36499     } catch (...) {
36500       {
36501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36502       };
36503     }
36504   }
36505
36506   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36507   return jresult;
36508 }
36509
36510
36511 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36512   float jresult ;
36513   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36514   float arg2 ;
36515   float result;
36516
36517   arg1 = (Dali::Actor *)jarg1;
36518   arg2 = (float)jarg2;
36519   {
36520     try {
36521       result = (float)(arg1)->GetHeightForWidth(arg2);
36522     } catch (std::out_of_range& e) {
36523       {
36524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36525       };
36526     } catch (std::exception& e) {
36527       {
36528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36529       };
36530     } catch (Dali::DaliException e) {
36531       {
36532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36533       };
36534     } catch (...) {
36535       {
36536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36537       };
36538     }
36539   }
36540
36541   jresult = result;
36542   return jresult;
36543 }
36544
36545
36546 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36547   float jresult ;
36548   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36549   float arg2 ;
36550   float result;
36551
36552   arg1 = (Dali::Actor *)jarg1;
36553   arg2 = (float)jarg2;
36554   {
36555     try {
36556       result = (float)(arg1)->GetWidthForHeight(arg2);
36557     } catch (std::out_of_range& e) {
36558       {
36559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36560       };
36561     } catch (std::exception& e) {
36562       {
36563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36564       };
36565     } catch (Dali::DaliException e) {
36566       {
36567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36568       };
36569     } catch (...) {
36570       {
36571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36572       };
36573     }
36574   }
36575
36576   jresult = result;
36577   return jresult;
36578 }
36579
36580
36581 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36582   float jresult ;
36583   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36584   Dali::Dimension::Type arg2 ;
36585   float result;
36586
36587   arg1 = (Dali::Actor *)jarg1;
36588   arg2 = (Dali::Dimension::Type)jarg2;
36589   {
36590     try {
36591       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36592     } catch (std::out_of_range& e) {
36593       {
36594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36595       };
36596     } catch (std::exception& e) {
36597       {
36598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36599       };
36600     } catch (Dali::DaliException e) {
36601       {
36602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36603       };
36604     } catch (...) {
36605       {
36606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36607       };
36608     }
36609   }
36610
36611   jresult = result;
36612   return jresult;
36613 }
36614
36615
36616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36617   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36618   Dali::Padding *arg2 = 0 ;
36619
36620   arg1 = (Dali::Actor *)jarg1;
36621   arg2 = (Dali::Padding *)jarg2;
36622   if (!arg2) {
36623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36624     return ;
36625   }
36626   {
36627     try {
36628       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36629     } catch (std::out_of_range& e) {
36630       {
36631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36632       };
36633     } catch (std::exception& e) {
36634       {
36635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36636       };
36637     } catch (Dali::DaliException e) {
36638       {
36639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36640       };
36641     } catch (...) {
36642       {
36643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36644       };
36645     }
36646   }
36647
36648 }
36649
36650
36651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36652   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36653   Dali::Padding *arg2 = 0 ;
36654
36655   arg1 = (Dali::Actor *)jarg1;
36656   arg2 = (Dali::Padding *)jarg2;
36657   if (!arg2) {
36658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36659     return ;
36660   }
36661   {
36662     try {
36663       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36664     } catch (std::out_of_range& e) {
36665       {
36666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36667       };
36668     } catch (std::exception& e) {
36669       {
36670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36671       };
36672     } catch (Dali::DaliException e) {
36673       {
36674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36675       };
36676     } catch (...) {
36677       {
36678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36679       };
36680     }
36681   }
36682
36683 }
36684
36685
36686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36687   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36688   Dali::Vector2 *arg2 = 0 ;
36689
36690   arg1 = (Dali::Actor *)jarg1;
36691   arg2 = (Dali::Vector2 *)jarg2;
36692   if (!arg2) {
36693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36694     return ;
36695   }
36696   {
36697     try {
36698       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36699     } catch (std::out_of_range& e) {
36700       {
36701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36702       };
36703     } catch (std::exception& e) {
36704       {
36705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36706       };
36707     } catch (Dali::DaliException e) {
36708       {
36709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36710       };
36711     } catch (...) {
36712       {
36713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36714       };
36715     }
36716   }
36717
36718 }
36719
36720
36721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36722   void * jresult ;
36723   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36724   Dali::Vector2 result;
36725
36726   arg1 = (Dali::Actor *)jarg1;
36727   {
36728     try {
36729       result = (arg1)->GetMinimumSize();
36730     } catch (std::out_of_range& e) {
36731       {
36732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36733       };
36734     } catch (std::exception& e) {
36735       {
36736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36737       };
36738     } catch (Dali::DaliException e) {
36739       {
36740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36741       };
36742     } catch (...) {
36743       {
36744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36745       };
36746     }
36747   }
36748
36749   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36750   return jresult;
36751 }
36752
36753
36754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36755   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36756   Dali::Vector2 *arg2 = 0 ;
36757
36758   arg1 = (Dali::Actor *)jarg1;
36759   arg2 = (Dali::Vector2 *)jarg2;
36760   if (!arg2) {
36761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36762     return ;
36763   }
36764   {
36765     try {
36766       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36767     } catch (std::out_of_range& e) {
36768       {
36769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36770       };
36771     } catch (std::exception& e) {
36772       {
36773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36774       };
36775     } catch (Dali::DaliException e) {
36776       {
36777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36778       };
36779     } catch (...) {
36780       {
36781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36782       };
36783     }
36784   }
36785
36786 }
36787
36788
36789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36790   void * jresult ;
36791   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36792   Dali::Vector2 result;
36793
36794   arg1 = (Dali::Actor *)jarg1;
36795   {
36796     try {
36797       result = (arg1)->GetMaximumSize();
36798     } catch (std::out_of_range& e) {
36799       {
36800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36801       };
36802     } catch (std::exception& e) {
36803       {
36804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36805       };
36806     } catch (Dali::DaliException e) {
36807       {
36808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36809       };
36810     } catch (...) {
36811       {
36812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36813       };
36814     }
36815   }
36816
36817   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36818   return jresult;
36819 }
36820
36821
36822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36823   int jresult ;
36824   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36825   int result;
36826
36827   arg1 = (Dali::Actor *)jarg1;
36828   {
36829     try {
36830       result = (int)(arg1)->GetHierarchyDepth();
36831       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36832     } catch (std::out_of_range& e) {
36833       {
36834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36835       };
36836     } catch (std::exception& e) {
36837       {
36838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36839       };
36840     } catch (Dali::DaliException e) {
36841       {
36842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36843       };
36844     } catch (...) {
36845       {
36846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36847       };
36848     }
36849   }
36850
36851   jresult = result;
36852   return jresult;
36853 }
36854
36855
36856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36857   unsigned int jresult ;
36858   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36859   Dali::Renderer *arg2 = 0 ;
36860   unsigned int result;
36861
36862   arg1 = (Dali::Actor *)jarg1;
36863   arg2 = (Dali::Renderer *)jarg2;
36864   if (!arg2) {
36865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36866     return 0;
36867   }
36868   {
36869     try {
36870       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36871     } catch (std::out_of_range& e) {
36872       {
36873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36874       };
36875     } catch (std::exception& e) {
36876       {
36877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36878       };
36879     } catch (Dali::DaliException e) {
36880       {
36881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36882       };
36883     } catch (...) {
36884       {
36885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36886       };
36887     }
36888   }
36889
36890   jresult = result;
36891   return jresult;
36892 }
36893
36894
36895 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36896   unsigned int jresult ;
36897   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36898   unsigned int result;
36899
36900   arg1 = (Dali::Actor *)jarg1;
36901   {
36902     try {
36903       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36904     } catch (std::out_of_range& e) {
36905       {
36906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36907       };
36908     } catch (std::exception& e) {
36909       {
36910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36911       };
36912     } catch (Dali::DaliException e) {
36913       {
36914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36915       };
36916     } catch (...) {
36917       {
36918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36919       };
36920     }
36921   }
36922
36923   jresult = result;
36924   return jresult;
36925 }
36926
36927
36928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36929   void * jresult ;
36930   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36931   unsigned int arg2 ;
36932   Dali::Renderer result;
36933
36934   arg1 = (Dali::Actor *)jarg1;
36935   arg2 = (unsigned int)jarg2;
36936   {
36937     try {
36938       result = (arg1)->GetRendererAt(arg2);
36939     } catch (std::out_of_range& e) {
36940       {
36941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36942       };
36943     } catch (std::exception& e) {
36944       {
36945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36946       };
36947     } catch (Dali::DaliException e) {
36948       {
36949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36950       };
36951     } catch (...) {
36952       {
36953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36954       };
36955     }
36956   }
36957
36958   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36959   return jresult;
36960 }
36961
36962
36963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36964   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36965   Dali::Renderer *arg2 = 0 ;
36966
36967   arg1 = (Dali::Actor *)jarg1;
36968   arg2 = (Dali::Renderer *)jarg2;
36969   if (!arg2) {
36970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36971     return ;
36972   }
36973   {
36974     try {
36975       (arg1)->RemoveRenderer(*arg2);
36976     } catch (std::out_of_range& e) {
36977       {
36978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36979       };
36980     } catch (std::exception& e) {
36981       {
36982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36983       };
36984     } catch (Dali::DaliException e) {
36985       {
36986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36987       };
36988     } catch (...) {
36989       {
36990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36991       };
36992     }
36993   }
36994
36995 }
36996
36997
36998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36999   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37000   unsigned int arg2 ;
37001
37002   arg1 = (Dali::Actor *)jarg1;
37003   arg2 = (unsigned int)jarg2;
37004   {
37005     try {
37006       (arg1)->RemoveRenderer(arg2);
37007     } catch (std::out_of_range& e) {
37008       {
37009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37010       };
37011     } catch (std::exception& e) {
37012       {
37013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37014       };
37015     } catch (Dali::DaliException e) {
37016       {
37017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37018       };
37019     } catch (...) {
37020       {
37021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37022       };
37023     }
37024   }
37025
37026 }
37027
37028
37029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
37030   void * jresult ;
37031   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37032   Dali::Actor::TouchSignalType *result = 0 ;
37033
37034   arg1 = (Dali::Actor *)jarg1;
37035   {
37036     try {
37037       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
37038     } catch (std::out_of_range& e) {
37039       {
37040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37041       };
37042     } catch (std::exception& e) {
37043       {
37044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37045       };
37046     } catch (Dali::DaliException e) {
37047       {
37048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37049       };
37050     } catch (...) {
37051       {
37052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37053       };
37054     }
37055   }
37056
37057   jresult = (void *)result;
37058   return jresult;
37059 }
37060
37061
37062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
37063   void * jresult ;
37064   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37065   Dali::Actor::TouchDataSignalType *result = 0 ;
37066
37067   arg1 = (Dali::Actor *)jarg1;
37068   {
37069     try {
37070       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
37071     } catch (std::out_of_range& e) {
37072       {
37073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37074       };
37075     } catch (std::exception& e) {
37076       {
37077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37078       };
37079     } catch (Dali::DaliException e) {
37080       {
37081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37082       };
37083     } catch (...) {
37084       {
37085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37086       };
37087     }
37088   }
37089
37090   jresult = (void *)result;
37091   return jresult;
37092 }
37093
37094
37095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
37096   void * jresult ;
37097   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37098   Dali::Actor::HoverSignalType *result = 0 ;
37099
37100   arg1 = (Dali::Actor *)jarg1;
37101   {
37102     try {
37103       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
37104     } catch (std::out_of_range& e) {
37105       {
37106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37107       };
37108     } catch (std::exception& e) {
37109       {
37110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37111       };
37112     } catch (Dali::DaliException e) {
37113       {
37114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37115       };
37116     } catch (...) {
37117       {
37118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37119       };
37120     }
37121   }
37122
37123   jresult = (void *)result;
37124   return jresult;
37125 }
37126
37127
37128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
37129   void * jresult ;
37130   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37131   Dali::Actor::WheelEventSignalType *result = 0 ;
37132
37133   arg1 = (Dali::Actor *)jarg1;
37134   {
37135     try {
37136       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37137     } catch (std::out_of_range& e) {
37138       {
37139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37140       };
37141     } catch (std::exception& e) {
37142       {
37143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37144       };
37145     } catch (Dali::DaliException e) {
37146       {
37147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37148       };
37149     } catch (...) {
37150       {
37151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37152       };
37153     }
37154   }
37155
37156   jresult = (void *)result;
37157   return jresult;
37158 }
37159
37160
37161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
37162   void * jresult ;
37163   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37164   Dali::Actor::OnStageSignalType *result = 0 ;
37165
37166   arg1 = (Dali::Actor *)jarg1;
37167   {
37168     try {
37169       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37170     } catch (std::out_of_range& e) {
37171       {
37172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37173       };
37174     } catch (std::exception& e) {
37175       {
37176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37177       };
37178     } catch (Dali::DaliException e) {
37179       {
37180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37181       };
37182     } catch (...) {
37183       {
37184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37185       };
37186     }
37187   }
37188
37189   jresult = (void *)result;
37190   return jresult;
37191 }
37192
37193
37194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37195   void * jresult ;
37196   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37197   Dali::Actor::OffStageSignalType *result = 0 ;
37198
37199   arg1 = (Dali::Actor *)jarg1;
37200   {
37201     try {
37202       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37203     } catch (std::out_of_range& e) {
37204       {
37205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37206       };
37207     } catch (std::exception& e) {
37208       {
37209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37210       };
37211     } catch (Dali::DaliException e) {
37212       {
37213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37214       };
37215     } catch (...) {
37216       {
37217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37218       };
37219     }
37220   }
37221
37222   jresult = (void *)result;
37223   return jresult;
37224 }
37225
37226
37227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37228   void * jresult ;
37229   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37230   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37231
37232   arg1 = (Dali::Actor *)jarg1;
37233   {
37234     try {
37235       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37236     } catch (std::out_of_range& e) {
37237       {
37238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37239       };
37240     } catch (std::exception& e) {
37241       {
37242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37243       };
37244     } catch (Dali::DaliException e) {
37245       {
37246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37247       };
37248     } catch (...) {
37249       {
37250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37251       };
37252     }
37253   }
37254
37255   jresult = (void *)result;
37256   return jresult;
37257 }
37258
37259
37260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37261   Dali::Actor *arg1 = 0 ;
37262
37263   arg1 = (Dali::Actor *)jarg1;
37264   if (!arg1) {
37265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37266     return ;
37267   }
37268   {
37269     try {
37270       Dali::UnparentAndReset(*arg1);
37271     } catch (std::out_of_range& e) {
37272       {
37273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37274       };
37275     } catch (std::exception& e) {
37276       {
37277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37278       };
37279     } catch (Dali::DaliException e) {
37280       {
37281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37282       };
37283     } catch (...) {
37284       {
37285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37286       };
37287     }
37288   }
37289
37290 }
37291
37292
37293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37294   int jresult ;
37295   int result;
37296
37297   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37298   jresult = (int)result;
37299   return jresult;
37300 }
37301
37302
37303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37304   int jresult ;
37305   int result;
37306
37307   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37308   jresult = (int)result;
37309   return jresult;
37310 }
37311
37312
37313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37314   int jresult ;
37315   int result;
37316
37317   result = (int)Dali::Layer::Property::BEHAVIOR;
37318   jresult = (int)result;
37319   return jresult;
37320 }
37321
37322
37323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37324   void * jresult ;
37325   Dali::Layer::Property *result = 0 ;
37326
37327   {
37328     try {
37329       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37330     } catch (std::out_of_range& e) {
37331       {
37332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37333       };
37334     } catch (std::exception& e) {
37335       {
37336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37337       };
37338     } catch (Dali::DaliException e) {
37339       {
37340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37341       };
37342     } catch (...) {
37343       {
37344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37345       };
37346     }
37347   }
37348
37349   jresult = (void *)result;
37350   return jresult;
37351 }
37352
37353
37354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37355   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37356
37357   arg1 = (Dali::Layer::Property *)jarg1;
37358   {
37359     try {
37360       delete arg1;
37361     } catch (std::out_of_range& e) {
37362       {
37363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37364       };
37365     } catch (std::exception& e) {
37366       {
37367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37368       };
37369     } catch (Dali::DaliException e) {
37370       {
37371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37372       };
37373     } catch (...) {
37374       {
37375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37376       };
37377     }
37378   }
37379
37380 }
37381
37382
37383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37384   void * jresult ;
37385   Dali::Layer *result = 0 ;
37386
37387   {
37388     try {
37389       result = (Dali::Layer *)new Dali::Layer();
37390     } catch (std::out_of_range& e) {
37391       {
37392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37393       };
37394     } catch (std::exception& e) {
37395       {
37396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37397       };
37398     } catch (Dali::DaliException e) {
37399       {
37400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37401       };
37402     } catch (...) {
37403       {
37404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37405       };
37406     }
37407   }
37408
37409   jresult = (void *)result;
37410   return jresult;
37411 }
37412
37413
37414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37415   void * jresult ;
37416   Dali::Layer result;
37417
37418   {
37419     try {
37420       result = Dali::Layer::New();
37421     } catch (std::out_of_range& e) {
37422       {
37423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37424       };
37425     } catch (std::exception& e) {
37426       {
37427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37428       };
37429     } catch (Dali::DaliException e) {
37430       {
37431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37432       };
37433     } catch (...) {
37434       {
37435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37436       };
37437     }
37438   }
37439
37440   jresult = new Dali::Layer((const Dali::Layer &)result);
37441   return jresult;
37442 }
37443
37444
37445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37446   void * jresult ;
37447   Dali::BaseHandle arg1 ;
37448   Dali::BaseHandle *argp1 ;
37449   Dali::Layer result;
37450
37451   argp1 = (Dali::BaseHandle *)jarg1;
37452   if (!argp1) {
37453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37454     return 0;
37455   }
37456   arg1 = *argp1;
37457   {
37458     try {
37459       result = Dali::Layer::DownCast(arg1);
37460     } catch (std::out_of_range& e) {
37461       {
37462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37463       };
37464     } catch (std::exception& e) {
37465       {
37466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37467       };
37468     } catch (Dali::DaliException e) {
37469       {
37470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37471       };
37472     } catch (...) {
37473       {
37474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37475       };
37476     }
37477   }
37478
37479   jresult = new Dali::Layer((const Dali::Layer &)result);
37480   return jresult;
37481 }
37482
37483
37484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37485   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37486
37487   arg1 = (Dali::Layer *)jarg1;
37488   {
37489     try {
37490       delete arg1;
37491     } catch (std::out_of_range& e) {
37492       {
37493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37494       };
37495     } catch (std::exception& e) {
37496       {
37497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37498       };
37499     } catch (Dali::DaliException e) {
37500       {
37501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37502       };
37503     } catch (...) {
37504       {
37505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37506       };
37507     }
37508   }
37509
37510 }
37511
37512
37513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37514   void * jresult ;
37515   Dali::Layer *arg1 = 0 ;
37516   Dali::Layer *result = 0 ;
37517
37518   arg1 = (Dali::Layer *)jarg1;
37519   if (!arg1) {
37520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37521     return 0;
37522   }
37523   {
37524     try {
37525       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37526     } catch (std::out_of_range& e) {
37527       {
37528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37529       };
37530     } catch (std::exception& e) {
37531       {
37532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37533       };
37534     } catch (Dali::DaliException e) {
37535       {
37536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37537       };
37538     } catch (...) {
37539       {
37540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37541       };
37542     }
37543   }
37544
37545   jresult = (void *)result;
37546   return jresult;
37547 }
37548
37549
37550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37551   void * jresult ;
37552   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37553   Dali::Layer *arg2 = 0 ;
37554   Dali::Layer *result = 0 ;
37555
37556   arg1 = (Dali::Layer *)jarg1;
37557   arg2 = (Dali::Layer *)jarg2;
37558   if (!arg2) {
37559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37560     return 0;
37561   }
37562   {
37563     try {
37564       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37565     } catch (std::out_of_range& e) {
37566       {
37567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37568       };
37569     } catch (std::exception& e) {
37570       {
37571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37572       };
37573     } catch (Dali::DaliException e) {
37574       {
37575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37576       };
37577     } catch (...) {
37578       {
37579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37580       };
37581     }
37582   }
37583
37584   jresult = (void *)result;
37585   return jresult;
37586 }
37587
37588
37589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37590   unsigned int jresult ;
37591   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37592   unsigned int result;
37593
37594   arg1 = (Dali::Layer *)jarg1;
37595   {
37596     try {
37597       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37598     } catch (std::out_of_range& e) {
37599       {
37600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37601       };
37602     } catch (std::exception& e) {
37603       {
37604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37605       };
37606     } catch (Dali::DaliException e) {
37607       {
37608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37609       };
37610     } catch (...) {
37611       {
37612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37613       };
37614     }
37615   }
37616
37617   jresult = result;
37618   return jresult;
37619 }
37620
37621
37622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37623   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37624
37625   arg1 = (Dali::Layer *)jarg1;
37626   {
37627     try {
37628       (arg1)->Raise();
37629     } catch (std::out_of_range& e) {
37630       {
37631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37632       };
37633     } catch (std::exception& e) {
37634       {
37635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37636       };
37637     } catch (Dali::DaliException e) {
37638       {
37639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37640       };
37641     } catch (...) {
37642       {
37643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37644       };
37645     }
37646   }
37647
37648 }
37649
37650
37651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37652   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37653
37654   arg1 = (Dali::Layer *)jarg1;
37655   {
37656     try {
37657       (arg1)->Lower();
37658     } catch (std::out_of_range& e) {
37659       {
37660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37661       };
37662     } catch (std::exception& e) {
37663       {
37664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37665       };
37666     } catch (Dali::DaliException e) {
37667       {
37668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37669       };
37670     } catch (...) {
37671       {
37672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37673       };
37674     }
37675   }
37676
37677 }
37678
37679
37680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37681   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37682   Dali::Layer arg2 ;
37683   Dali::Layer *argp2 ;
37684
37685   arg1 = (Dali::Layer *)jarg1;
37686   argp2 = (Dali::Layer *)jarg2;
37687   if (!argp2) {
37688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37689     return ;
37690   }
37691   arg2 = *argp2;
37692   {
37693     try {
37694       (arg1)->RaiseAbove(arg2);
37695     } catch (std::out_of_range& e) {
37696       {
37697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37698       };
37699     } catch (std::exception& e) {
37700       {
37701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37702       };
37703     } catch (Dali::DaliException e) {
37704       {
37705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37706       };
37707     } catch (...) {
37708       {
37709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37710       };
37711     }
37712   }
37713
37714 }
37715
37716
37717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37718   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37719   Dali::Layer arg2 ;
37720   Dali::Layer *argp2 ;
37721
37722   arg1 = (Dali::Layer *)jarg1;
37723   argp2 = (Dali::Layer *)jarg2;
37724   if (!argp2) {
37725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37726     return ;
37727   }
37728   arg2 = *argp2;
37729   {
37730     try {
37731       (arg1)->LowerBelow(arg2);
37732     } catch (std::out_of_range& e) {
37733       {
37734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37735       };
37736     } catch (std::exception& e) {
37737       {
37738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37739       };
37740     } catch (Dali::DaliException e) {
37741       {
37742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37743       };
37744     } catch (...) {
37745       {
37746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37747       };
37748     }
37749   }
37750
37751 }
37752
37753
37754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37755   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37756
37757   arg1 = (Dali::Layer *)jarg1;
37758   {
37759     try {
37760       (arg1)->RaiseToTop();
37761     } catch (std::out_of_range& e) {
37762       {
37763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37764       };
37765     } catch (std::exception& e) {
37766       {
37767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37768       };
37769     } catch (Dali::DaliException e) {
37770       {
37771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37772       };
37773     } catch (...) {
37774       {
37775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37776       };
37777     }
37778   }
37779
37780 }
37781
37782
37783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37784   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37785
37786   arg1 = (Dali::Layer *)jarg1;
37787   {
37788     try {
37789       (arg1)->LowerToBottom();
37790     } catch (std::out_of_range& e) {
37791       {
37792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37793       };
37794     } catch (std::exception& e) {
37795       {
37796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37797       };
37798     } catch (Dali::DaliException e) {
37799       {
37800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37801       };
37802     } catch (...) {
37803       {
37804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37805       };
37806     }
37807   }
37808
37809 }
37810
37811
37812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37813   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37814   Dali::Layer arg2 ;
37815   Dali::Layer *argp2 ;
37816
37817   arg1 = (Dali::Layer *)jarg1;
37818   argp2 = (Dali::Layer *)jarg2;
37819   if (!argp2) {
37820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37821     return ;
37822   }
37823   arg2 = *argp2;
37824   {
37825     try {
37826       (arg1)->MoveAbove(arg2);
37827     } catch (std::out_of_range& e) {
37828       {
37829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37830       };
37831     } catch (std::exception& e) {
37832       {
37833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37834       };
37835     } catch (Dali::DaliException e) {
37836       {
37837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37838       };
37839     } catch (...) {
37840       {
37841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37842       };
37843     }
37844   }
37845
37846 }
37847
37848
37849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37850   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37851   Dali::Layer arg2 ;
37852   Dali::Layer *argp2 ;
37853
37854   arg1 = (Dali::Layer *)jarg1;
37855   argp2 = (Dali::Layer *)jarg2;
37856   if (!argp2) {
37857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37858     return ;
37859   }
37860   arg2 = *argp2;
37861   {
37862     try {
37863       (arg1)->MoveBelow(arg2);
37864     } catch (std::out_of_range& e) {
37865       {
37866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37867       };
37868     } catch (std::exception& e) {
37869       {
37870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37871       };
37872     } catch (Dali::DaliException e) {
37873       {
37874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37875       };
37876     } catch (...) {
37877       {
37878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37879       };
37880     }
37881   }
37882
37883 }
37884
37885
37886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37887   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37888   Dali::Layer::Behavior arg2 ;
37889
37890   arg1 = (Dali::Layer *)jarg1;
37891   arg2 = (Dali::Layer::Behavior)jarg2;
37892   {
37893     try {
37894       (arg1)->SetBehavior(arg2);
37895     } catch (std::out_of_range& e) {
37896       {
37897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37898       };
37899     } catch (std::exception& e) {
37900       {
37901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37902       };
37903     } catch (Dali::DaliException e) {
37904       {
37905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37906       };
37907     } catch (...) {
37908       {
37909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37910       };
37911     }
37912   }
37913
37914 }
37915
37916
37917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37918   int jresult ;
37919   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37920   Dali::Layer::Behavior result;
37921
37922   arg1 = (Dali::Layer *)jarg1;
37923   {
37924     try {
37925       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37926     } catch (std::out_of_range& e) {
37927       {
37928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37929       };
37930     } catch (std::exception& e) {
37931       {
37932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37933       };
37934     } catch (Dali::DaliException e) {
37935       {
37936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37937       };
37938     } catch (...) {
37939       {
37940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37941       };
37942     }
37943   }
37944
37945   jresult = (int)result;
37946   return jresult;
37947 }
37948
37949
37950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37951   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37952   bool arg2 ;
37953
37954   arg1 = (Dali::Layer *)jarg1;
37955   arg2 = jarg2 ? true : false;
37956   {
37957     try {
37958       (arg1)->SetClipping(arg2);
37959     } catch (std::out_of_range& e) {
37960       {
37961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37962       };
37963     } catch (std::exception& e) {
37964       {
37965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37966       };
37967     } catch (Dali::DaliException e) {
37968       {
37969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37970       };
37971     } catch (...) {
37972       {
37973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37974       };
37975     }
37976   }
37977
37978 }
37979
37980
37981 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37982   unsigned int jresult ;
37983   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37984   bool result;
37985
37986   arg1 = (Dali::Layer *)jarg1;
37987   {
37988     try {
37989       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37990     } catch (std::out_of_range& e) {
37991       {
37992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37993       };
37994     } catch (std::exception& e) {
37995       {
37996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37997       };
37998     } catch (Dali::DaliException e) {
37999       {
38000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38001       };
38002     } catch (...) {
38003       {
38004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38005       };
38006     }
38007   }
38008
38009   jresult = result;
38010   return jresult;
38011 }
38012
38013
38014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
38015   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38016   int arg2 ;
38017   int arg3 ;
38018   int arg4 ;
38019   int arg5 ;
38020
38021   arg1 = (Dali::Layer *)jarg1;
38022   arg2 = (int)jarg2;
38023   arg3 = (int)jarg3;
38024   arg4 = (int)jarg4;
38025   arg5 = (int)jarg5;
38026   {
38027     try {
38028       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
38029     } catch (std::out_of_range& e) {
38030       {
38031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38032       };
38033     } catch (std::exception& e) {
38034       {
38035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38036       };
38037     } catch (Dali::DaliException e) {
38038       {
38039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38040       };
38041     } catch (...) {
38042       {
38043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38044       };
38045     }
38046   }
38047
38048 }
38049
38050
38051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
38052   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38053   Dali::ClippingBox arg2 ;
38054   Dali::ClippingBox *argp2 ;
38055
38056   arg1 = (Dali::Layer *)jarg1;
38057   argp2 = (Dali::ClippingBox *)jarg2;
38058   if (!argp2) {
38059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
38060     return ;
38061   }
38062   arg2 = *argp2;
38063   {
38064     try {
38065       (arg1)->SetClippingBox(arg2);
38066     } catch (std::out_of_range& e) {
38067       {
38068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38069       };
38070     } catch (std::exception& e) {
38071       {
38072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38073       };
38074     } catch (Dali::DaliException e) {
38075       {
38076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38077       };
38078     } catch (...) {
38079       {
38080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38081       };
38082     }
38083   }
38084
38085 }
38086
38087
38088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
38089   void * jresult ;
38090   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38091   Dali::ClippingBox result;
38092
38093   arg1 = (Dali::Layer *)jarg1;
38094   {
38095     try {
38096       result = ((Dali::Layer const *)arg1)->GetClippingBox();
38097     } catch (std::out_of_range& e) {
38098       {
38099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38100       };
38101     } catch (std::exception& e) {
38102       {
38103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38104       };
38105     } catch (Dali::DaliException e) {
38106       {
38107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38108       };
38109     } catch (...) {
38110       {
38111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38112       };
38113     }
38114   }
38115
38116   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
38117   return jresult;
38118 }
38119
38120
38121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
38122   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38123   bool arg2 ;
38124
38125   arg1 = (Dali::Layer *)jarg1;
38126   arg2 = jarg2 ? true : false;
38127   {
38128     try {
38129       (arg1)->SetDepthTestDisabled(arg2);
38130     } catch (std::out_of_range& e) {
38131       {
38132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38133       };
38134     } catch (std::exception& e) {
38135       {
38136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38137       };
38138     } catch (Dali::DaliException e) {
38139       {
38140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38141       };
38142     } catch (...) {
38143       {
38144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38145       };
38146     }
38147   }
38148
38149 }
38150
38151
38152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38153   unsigned int jresult ;
38154   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38155   bool result;
38156
38157   arg1 = (Dali::Layer *)jarg1;
38158   {
38159     try {
38160       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
38161     } catch (std::out_of_range& e) {
38162       {
38163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38164       };
38165     } catch (std::exception& e) {
38166       {
38167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38168       };
38169     } catch (Dali::DaliException e) {
38170       {
38171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38172       };
38173     } catch (...) {
38174       {
38175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38176       };
38177     }
38178   }
38179
38180   jresult = result;
38181   return jresult;
38182 }
38183
38184
38185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38186   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38187   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38188
38189   arg1 = (Dali::Layer *)jarg1;
38190   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38191   {
38192     try {
38193       (arg1)->SetSortFunction(arg2);
38194     } catch (std::out_of_range& e) {
38195       {
38196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38197       };
38198     } catch (std::exception& e) {
38199       {
38200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38201       };
38202     } catch (Dali::DaliException e) {
38203       {
38204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38205       };
38206     } catch (...) {
38207       {
38208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38209       };
38210     }
38211   }
38212
38213 }
38214
38215
38216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38217   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38218   bool arg2 ;
38219
38220   arg1 = (Dali::Layer *)jarg1;
38221   arg2 = jarg2 ? true : false;
38222   {
38223     try {
38224       (arg1)->SetTouchConsumed(arg2);
38225     } catch (std::out_of_range& e) {
38226       {
38227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38228       };
38229     } catch (std::exception& e) {
38230       {
38231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38232       };
38233     } catch (Dali::DaliException e) {
38234       {
38235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38236       };
38237     } catch (...) {
38238       {
38239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38240       };
38241     }
38242   }
38243
38244 }
38245
38246
38247 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38248   unsigned int jresult ;
38249   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38250   bool result;
38251
38252   arg1 = (Dali::Layer *)jarg1;
38253   {
38254     try {
38255       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38256     } catch (std::out_of_range& e) {
38257       {
38258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38259       };
38260     } catch (std::exception& e) {
38261       {
38262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38263       };
38264     } catch (Dali::DaliException e) {
38265       {
38266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38267       };
38268     } catch (...) {
38269       {
38270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38271       };
38272     }
38273   }
38274
38275   jresult = result;
38276   return jresult;
38277 }
38278
38279
38280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38281   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38282   bool arg2 ;
38283
38284   arg1 = (Dali::Layer *)jarg1;
38285   arg2 = jarg2 ? true : false;
38286   {
38287     try {
38288       (arg1)->SetHoverConsumed(arg2);
38289     } catch (std::out_of_range& e) {
38290       {
38291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38292       };
38293     } catch (std::exception& e) {
38294       {
38295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38296       };
38297     } catch (Dali::DaliException e) {
38298       {
38299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38300       };
38301     } catch (...) {
38302       {
38303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38304       };
38305     }
38306   }
38307
38308 }
38309
38310
38311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38312   unsigned int jresult ;
38313   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38314   bool result;
38315
38316   arg1 = (Dali::Layer *)jarg1;
38317   {
38318     try {
38319       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38320     } catch (std::out_of_range& e) {
38321       {
38322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38323       };
38324     } catch (std::exception& e) {
38325       {
38326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38327       };
38328     } catch (Dali::DaliException e) {
38329       {
38330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38331       };
38332     } catch (...) {
38333       {
38334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38335       };
38336     }
38337   }
38338
38339   jresult = result;
38340   return jresult;
38341 }
38342
38343
38344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38345   void * jresult ;
38346   Dali::Vector4 *result = 0 ;
38347
38348   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38349   jresult = (void *)result;
38350   return jresult;
38351 }
38352
38353
38354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38355   void * jresult ;
38356   Dali::Vector4 *result = 0 ;
38357
38358   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38359   jresult = (void *)result;
38360   return jresult;
38361 }
38362
38363
38364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38365   void * jresult ;
38366   Dali::Stage *result = 0 ;
38367
38368   {
38369     try {
38370       result = (Dali::Stage *)new Dali::Stage();
38371     } catch (std::out_of_range& e) {
38372       {
38373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38374       };
38375     } catch (std::exception& e) {
38376       {
38377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38378       };
38379     } catch (Dali::DaliException e) {
38380       {
38381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38382       };
38383     } catch (...) {
38384       {
38385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38386       };
38387     }
38388   }
38389
38390   jresult = (void *)result;
38391   return jresult;
38392 }
38393
38394
38395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38396   void * jresult ;
38397   Dali::Stage result;
38398
38399   {
38400     try {
38401       result = Dali::Stage::GetCurrent();
38402     } catch (std::out_of_range& e) {
38403       {
38404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38405       };
38406     } catch (std::exception& e) {
38407       {
38408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38409       };
38410     } catch (Dali::DaliException e) {
38411       {
38412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38413       };
38414     } catch (...) {
38415       {
38416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38417       };
38418     }
38419   }
38420
38421   jresult = new Dali::Stage((const Dali::Stage &)result);
38422   return jresult;
38423 }
38424
38425
38426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38427   unsigned int jresult ;
38428   bool result;
38429
38430   {
38431     try {
38432       result = (bool)Dali::Stage::IsInstalled();
38433     } catch (std::out_of_range& e) {
38434       {
38435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38436       };
38437     } catch (std::exception& e) {
38438       {
38439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38440       };
38441     } catch (Dali::DaliException e) {
38442       {
38443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38444       };
38445     } catch (...) {
38446       {
38447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38448       };
38449     }
38450   }
38451
38452   jresult = result;
38453   return jresult;
38454 }
38455
38456
38457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38458   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38459
38460   arg1 = (Dali::Stage *)jarg1;
38461   {
38462     try {
38463       delete arg1;
38464     } catch (std::out_of_range& e) {
38465       {
38466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38467       };
38468     } catch (std::exception& e) {
38469       {
38470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38471       };
38472     } catch (Dali::DaliException e) {
38473       {
38474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38475       };
38476     } catch (...) {
38477       {
38478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38479       };
38480     }
38481   }
38482
38483 }
38484
38485
38486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38487   void * jresult ;
38488   Dali::Stage *arg1 = 0 ;
38489   Dali::Stage *result = 0 ;
38490
38491   arg1 = (Dali::Stage *)jarg1;
38492   if (!arg1) {
38493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38494     return 0;
38495   }
38496   {
38497     try {
38498       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38499     } catch (std::out_of_range& e) {
38500       {
38501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38502       };
38503     } catch (std::exception& e) {
38504       {
38505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38506       };
38507     } catch (Dali::DaliException e) {
38508       {
38509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38510       };
38511     } catch (...) {
38512       {
38513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38514       };
38515     }
38516   }
38517
38518   jresult = (void *)result;
38519   return jresult;
38520 }
38521
38522
38523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38524   void * jresult ;
38525   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38526   Dali::Stage *arg2 = 0 ;
38527   Dali::Stage *result = 0 ;
38528
38529   arg1 = (Dali::Stage *)jarg1;
38530   arg2 = (Dali::Stage *)jarg2;
38531   if (!arg2) {
38532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38533     return 0;
38534   }
38535   {
38536     try {
38537       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38538     } catch (std::out_of_range& e) {
38539       {
38540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38541       };
38542     } catch (std::exception& e) {
38543       {
38544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38545       };
38546     } catch (Dali::DaliException e) {
38547       {
38548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38549       };
38550     } catch (...) {
38551       {
38552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38553       };
38554     }
38555   }
38556
38557   jresult = (void *)result;
38558   return jresult;
38559 }
38560
38561
38562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38563   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38564   Dali::Actor *arg2 = 0 ;
38565
38566   arg1 = (Dali::Stage *)jarg1;
38567   arg2 = (Dali::Actor *)jarg2;
38568   if (!arg2) {
38569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38570     return ;
38571   }
38572   {
38573     try {
38574       (arg1)->Add(*arg2);
38575     } catch (std::out_of_range& e) {
38576       {
38577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38578       };
38579     } catch (std::exception& e) {
38580       {
38581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38582       };
38583     } catch (Dali::DaliException e) {
38584       {
38585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38586       };
38587     } catch (...) {
38588       {
38589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38590       };
38591     }
38592   }
38593
38594 }
38595
38596
38597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38598   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38599   Dali::Actor *arg2 = 0 ;
38600
38601   arg1 = (Dali::Stage *)jarg1;
38602   arg2 = (Dali::Actor *)jarg2;
38603   if (!arg2) {
38604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38605     return ;
38606   }
38607   {
38608     try {
38609       (arg1)->Remove(*arg2);
38610     } catch (std::out_of_range& e) {
38611       {
38612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38613       };
38614     } catch (std::exception& e) {
38615       {
38616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38617       };
38618     } catch (Dali::DaliException e) {
38619       {
38620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38621       };
38622     } catch (...) {
38623       {
38624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38625       };
38626     }
38627   }
38628
38629 }
38630
38631
38632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38633   void * jresult ;
38634   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38635   Dali::Vector2 result;
38636
38637   arg1 = (Dali::Stage *)jarg1;
38638   {
38639     try {
38640       result = ((Dali::Stage const *)arg1)->GetSize();
38641     } catch (std::out_of_range& e) {
38642       {
38643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38644       };
38645     } catch (std::exception& e) {
38646       {
38647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38648       };
38649     } catch (Dali::DaliException e) {
38650       {
38651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38652       };
38653     } catch (...) {
38654       {
38655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38656       };
38657     }
38658   }
38659
38660   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38661   return jresult;
38662 }
38663
38664
38665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38666   void * jresult ;
38667   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38668   Dali::RenderTaskList result;
38669
38670   arg1 = (Dali::Stage *)jarg1;
38671   {
38672     try {
38673       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38674     } catch (std::out_of_range& e) {
38675       {
38676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38677       };
38678     } catch (std::exception& e) {
38679       {
38680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38681       };
38682     } catch (Dali::DaliException e) {
38683       {
38684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38685       };
38686     } catch (...) {
38687       {
38688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38689       };
38690     }
38691   }
38692
38693   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38694   return jresult;
38695 }
38696
38697
38698 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38699   unsigned int jresult ;
38700   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38701   unsigned int result;
38702
38703   arg1 = (Dali::Stage *)jarg1;
38704   {
38705     try {
38706       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38707     } catch (std::out_of_range& e) {
38708       {
38709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38710       };
38711     } catch (std::exception& e) {
38712       {
38713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38714       };
38715     } catch (Dali::DaliException e) {
38716       {
38717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38718       };
38719     } catch (...) {
38720       {
38721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38722       };
38723     }
38724   }
38725
38726   jresult = result;
38727   return jresult;
38728 }
38729
38730
38731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38732   void * jresult ;
38733   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38734   unsigned int arg2 ;
38735   Dali::Layer result;
38736
38737   arg1 = (Dali::Stage *)jarg1;
38738   arg2 = (unsigned int)jarg2;
38739   {
38740     try {
38741       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38742     } catch (std::out_of_range& e) {
38743       {
38744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38745       };
38746     } catch (std::exception& e) {
38747       {
38748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38749       };
38750     } catch (Dali::DaliException e) {
38751       {
38752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38753       };
38754     } catch (...) {
38755       {
38756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38757       };
38758     }
38759   }
38760
38761   jresult = new Dali::Layer((const Dali::Layer &)result);
38762   return jresult;
38763 }
38764
38765
38766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38767   void * jresult ;
38768   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38769   Dali::Layer result;
38770
38771   arg1 = (Dali::Stage *)jarg1;
38772   {
38773     try {
38774       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38775     } catch (std::out_of_range& e) {
38776       {
38777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38778       };
38779     } catch (std::exception& e) {
38780       {
38781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38782       };
38783     } catch (Dali::DaliException e) {
38784       {
38785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38786       };
38787     } catch (...) {
38788       {
38789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38790       };
38791     }
38792   }
38793
38794   jresult = new Dali::Layer((const Dali::Layer &)result);
38795   return jresult;
38796 }
38797
38798
38799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38800   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38801   Dali::Vector4 arg2 ;
38802   Dali::Vector4 *argp2 ;
38803
38804   arg1 = (Dali::Stage *)jarg1;
38805   argp2 = (Dali::Vector4 *)jarg2;
38806   if (!argp2) {
38807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38808     return ;
38809   }
38810   arg2 = *argp2;
38811   {
38812     try {
38813       (arg1)->SetBackgroundColor(arg2);
38814     } catch (std::out_of_range& e) {
38815       {
38816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38817       };
38818     } catch (std::exception& e) {
38819       {
38820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38821       };
38822     } catch (Dali::DaliException e) {
38823       {
38824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38825       };
38826     } catch (...) {
38827       {
38828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38829       };
38830     }
38831   }
38832
38833 }
38834
38835
38836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38837   void * jresult ;
38838   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38839   Dali::Vector4 result;
38840
38841   arg1 = (Dali::Stage *)jarg1;
38842   {
38843     try {
38844       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38845     } catch (std::out_of_range& e) {
38846       {
38847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38848       };
38849     } catch (std::exception& e) {
38850       {
38851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38852       };
38853     } catch (Dali::DaliException e) {
38854       {
38855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38856       };
38857     } catch (...) {
38858       {
38859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38860       };
38861     }
38862   }
38863
38864   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38865   return jresult;
38866 }
38867
38868
38869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38870   void * jresult ;
38871   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38872   Dali::Vector2 result;
38873
38874   arg1 = (Dali::Stage *)jarg1;
38875   {
38876     try {
38877       result = ((Dali::Stage const *)arg1)->GetDpi();
38878     } catch (std::out_of_range& e) {
38879       {
38880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38881       };
38882     } catch (std::exception& e) {
38883       {
38884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38885       };
38886     } catch (Dali::DaliException e) {
38887       {
38888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38889       };
38890     } catch (...) {
38891       {
38892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38893       };
38894     }
38895   }
38896
38897   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38898   return jresult;
38899 }
38900
38901
38902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38903   void * jresult ;
38904   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38905   Dali::ObjectRegistry result;
38906
38907   arg1 = (Dali::Stage *)jarg1;
38908   {
38909     try {
38910       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38911     } catch (std::out_of_range& e) {
38912       {
38913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38914       };
38915     } catch (std::exception& e) {
38916       {
38917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38918       };
38919     } catch (Dali::DaliException e) {
38920       {
38921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38922       };
38923     } catch (...) {
38924       {
38925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38926       };
38927     }
38928   }
38929
38930   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38931   return jresult;
38932 }
38933
38934
38935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38936   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38937   float arg2 ;
38938
38939   arg1 = (Dali::Stage *)jarg1;
38940   arg2 = (float)jarg2;
38941   {
38942     try {
38943       (arg1)->KeepRendering(arg2);
38944     } catch (std::out_of_range& e) {
38945       {
38946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38947       };
38948     } catch (std::exception& e) {
38949       {
38950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38951       };
38952     } catch (Dali::DaliException e) {
38953       {
38954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38955       };
38956     } catch (...) {
38957       {
38958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38959       };
38960     }
38961   }
38962
38963 }
38964
38965
38966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38967   void * jresult ;
38968   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38969   Dali::Stage::KeyEventSignalType *result = 0 ;
38970
38971   arg1 = (Dali::Stage *)jarg1;
38972   {
38973     try {
38974       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38975     } catch (std::out_of_range& e) {
38976       {
38977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38978       };
38979     } catch (std::exception& e) {
38980       {
38981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38982       };
38983     } catch (Dali::DaliException e) {
38984       {
38985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38986       };
38987     } catch (...) {
38988       {
38989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38990       };
38991     }
38992   }
38993
38994   jresult = (void *)result;
38995   return jresult;
38996 }
38997
38998
38999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
39000   void * jresult ;
39001   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39002   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
39003
39004   arg1 = (Dali::Stage *)jarg1;
39005   {
39006     try {
39007       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
39008     } catch (std::out_of_range& e) {
39009       {
39010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39011       };
39012     } catch (std::exception& e) {
39013       {
39014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39015       };
39016     } catch (Dali::DaliException e) {
39017       {
39018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39019       };
39020     } catch (...) {
39021       {
39022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39023       };
39024     }
39025   }
39026
39027   jresult = (void *)result;
39028   return jresult;
39029 }
39030
39031
39032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
39033   void * jresult ;
39034   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39035   Dali::Stage::TouchSignalType *result = 0 ;
39036
39037   arg1 = (Dali::Stage *)jarg1;
39038   {
39039     try {
39040       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
39041     } catch (std::out_of_range& e) {
39042       {
39043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39044       };
39045     } catch (std::exception& e) {
39046       {
39047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39048       };
39049     } catch (Dali::DaliException e) {
39050       {
39051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39052       };
39053     } catch (...) {
39054       {
39055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39056       };
39057     }
39058   }
39059
39060   jresult = (void *)result;
39061   return jresult;
39062 }
39063
39064
39065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
39066   void * jresult ;
39067   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39068   Dali::Stage::WheelEventSignalType *result = 0 ;
39069
39070   arg1 = (Dali::Stage *)jarg1;
39071   {
39072     try {
39073       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
39074     } catch (std::out_of_range& e) {
39075       {
39076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39077       };
39078     } catch (std::exception& e) {
39079       {
39080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39081       };
39082     } catch (Dali::DaliException e) {
39083       {
39084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39085       };
39086     } catch (...) {
39087       {
39088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39089       };
39090     }
39091   }
39092
39093   jresult = (void *)result;
39094   return jresult;
39095 }
39096
39097
39098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
39099   void * jresult ;
39100   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39101   Dali::Stage::ContextStatusSignal *result = 0 ;
39102
39103   arg1 = (Dali::Stage *)jarg1;
39104   {
39105     try {
39106       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
39107     } catch (std::out_of_range& e) {
39108       {
39109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39110       };
39111     } catch (std::exception& e) {
39112       {
39113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39114       };
39115     } catch (Dali::DaliException e) {
39116       {
39117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39118       };
39119     } catch (...) {
39120       {
39121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39122       };
39123     }
39124   }
39125
39126   jresult = (void *)result;
39127   return jresult;
39128 }
39129
39130
39131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
39132   void * jresult ;
39133   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39134   Dali::Stage::ContextStatusSignal *result = 0 ;
39135
39136   arg1 = (Dali::Stage *)jarg1;
39137   {
39138     try {
39139       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
39140     } catch (std::out_of_range& e) {
39141       {
39142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39143       };
39144     } catch (std::exception& e) {
39145       {
39146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39147       };
39148     } catch (Dali::DaliException e) {
39149       {
39150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39151       };
39152     } catch (...) {
39153       {
39154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39155       };
39156     }
39157   }
39158
39159   jresult = (void *)result;
39160   return jresult;
39161 }
39162
39163
39164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
39165   void * jresult ;
39166   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39167   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39168
39169   arg1 = (Dali::Stage *)jarg1;
39170   {
39171     try {
39172       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39173     } catch (std::out_of_range& e) {
39174       {
39175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39176       };
39177     } catch (std::exception& e) {
39178       {
39179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39180       };
39181     } catch (Dali::DaliException e) {
39182       {
39183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39184       };
39185     } catch (...) {
39186       {
39187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39188       };
39189     }
39190   }
39191
39192   jresult = (void *)result;
39193   return jresult;
39194 }
39195
39196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
39197   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39198   Dali::DevelStage::Rendering arg2 ;
39199
39200   arg1 = (Dali::Stage *)jarg1;
39201   arg2 = (Dali::DevelStage::Rendering)jarg2;
39202   {
39203     try {
39204       DevelStage::SetRenderingBehavior(*arg1,arg2);
39205     } catch (std::out_of_range& e) {
39206       {
39207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39208       };
39209     } catch (std::exception& e) {
39210       {
39211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39212       };
39213     } catch (Dali::DaliException e) {
39214       {
39215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39216       };
39217     } catch (...) {
39218       {
39219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39220       };
39221     }
39222   }
39223
39224 }
39225
39226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
39227
39228   int jresult ;
39229   int result ;
39230   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39231
39232   arg1 = (Dali::Stage *)jarg1;
39233   {
39234     try {
39235       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
39236     } catch (std::out_of_range& e) {
39237       {
39238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39239       };
39240     } catch (std::exception& e) {
39241       {
39242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39243       };
39244     } catch (Dali::DaliException e) {
39245       {
39246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39247       };
39248     } catch (...) {
39249       {
39250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39251       };
39252     }
39253   }
39254
39255   jresult = result;
39256   return jresult;
39257 }
39258
39259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39260   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39261
39262   arg1 = (Dali::RelayoutContainer *)jarg1;
39263   {
39264     try {
39265       delete arg1;
39266     } catch (std::out_of_range& e) {
39267       {
39268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39269       };
39270     } catch (std::exception& e) {
39271       {
39272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39273       };
39274     } catch (Dali::DaliException e) {
39275       {
39276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39277       };
39278     } catch (...) {
39279       {
39280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39281       };
39282     }
39283   }
39284
39285 }
39286
39287
39288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39289   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39290   Dali::Actor *arg2 = 0 ;
39291   Dali::Vector2 *arg3 = 0 ;
39292
39293   arg1 = (Dali::RelayoutContainer *)jarg1;
39294   arg2 = (Dali::Actor *)jarg2;
39295   if (!arg2) {
39296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39297     return ;
39298   }
39299   arg3 = (Dali::Vector2 *)jarg3;
39300   if (!arg3) {
39301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39302     return ;
39303   }
39304   {
39305     try {
39306       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39307     } catch (std::out_of_range& e) {
39308       {
39309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39310       };
39311     } catch (std::exception& e) {
39312       {
39313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39314       };
39315     } catch (Dali::DaliException e) {
39316       {
39317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39318       };
39319     } catch (...) {
39320       {
39321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39322       };
39323     }
39324   }
39325
39326 }
39327
39328
39329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39330   void * jresult ;
39331   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39332   Dali::CustomActor result;
39333
39334   arg1 = (Dali::CustomActorImpl *)jarg1;
39335   {
39336     try {
39337       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39338     } catch (std::out_of_range& e) {
39339       {
39340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39341       };
39342     } catch (std::exception& e) {
39343       {
39344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39345       };
39346     } catch (Dali::DaliException e) {
39347       {
39348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39349       };
39350     } catch (...) {
39351       {
39352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39353       };
39354     }
39355   }
39356
39357   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39358   return jresult;
39359 }
39360
39361
39362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39363   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39364   int arg2 ;
39365
39366   arg1 = (Dali::CustomActorImpl *)jarg1;
39367   arg2 = (int)jarg2;
39368   {
39369     try {
39370       (arg1)->OnStageConnection(arg2);
39371     } catch (std::out_of_range& e) {
39372       {
39373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39374       };
39375     } catch (std::exception& e) {
39376       {
39377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39378       };
39379     } catch (Dali::DaliException e) {
39380       {
39381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39382       };
39383     } catch (...) {
39384       {
39385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39386       };
39387     }
39388   }
39389
39390 }
39391
39392
39393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39394   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39395
39396   arg1 = (Dali::CustomActorImpl *)jarg1;
39397   {
39398     try {
39399       (arg1)->OnStageDisconnection();
39400     } catch (std::out_of_range& e) {
39401       {
39402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39403       };
39404     } catch (std::exception& e) {
39405       {
39406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39407       };
39408     } catch (Dali::DaliException e) {
39409       {
39410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39411       };
39412     } catch (...) {
39413       {
39414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39415       };
39416     }
39417   }
39418
39419 }
39420
39421
39422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39423   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39424   Dali::Actor *arg2 = 0 ;
39425
39426   arg1 = (Dali::CustomActorImpl *)jarg1;
39427   arg2 = (Dali::Actor *)jarg2;
39428   if (!arg2) {
39429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39430     return ;
39431   }
39432   {
39433     try {
39434       (arg1)->OnChildAdd(*arg2);
39435     } catch (std::out_of_range& e) {
39436       {
39437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39438       };
39439     } catch (std::exception& e) {
39440       {
39441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39442       };
39443     } catch (Dali::DaliException e) {
39444       {
39445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39446       };
39447     } catch (...) {
39448       {
39449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39450       };
39451     }
39452   }
39453
39454 }
39455
39456
39457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39458   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39459   Dali::Actor *arg2 = 0 ;
39460
39461   arg1 = (Dali::CustomActorImpl *)jarg1;
39462   arg2 = (Dali::Actor *)jarg2;
39463   if (!arg2) {
39464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39465     return ;
39466   }
39467   {
39468     try {
39469       (arg1)->OnChildRemove(*arg2);
39470     } catch (std::out_of_range& e) {
39471       {
39472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39473       };
39474     } catch (std::exception& e) {
39475       {
39476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39477       };
39478     } catch (Dali::DaliException e) {
39479       {
39480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39481       };
39482     } catch (...) {
39483       {
39484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39485       };
39486     }
39487   }
39488
39489 }
39490
39491
39492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39493   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39494   Dali::Property::Index arg2 ;
39495   Dali::Property::Value arg3 ;
39496   Dali::Property::Value *argp3 ;
39497
39498   arg1 = (Dali::CustomActorImpl *)jarg1;
39499   arg2 = (Dali::Property::Index)jarg2;
39500   argp3 = (Dali::Property::Value *)jarg3;
39501   if (!argp3) {
39502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39503     return ;
39504   }
39505   arg3 = *argp3;
39506   {
39507     try {
39508       (arg1)->OnPropertySet(arg2,arg3);
39509     } catch (std::out_of_range& e) {
39510       {
39511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39512       };
39513     } catch (std::exception& e) {
39514       {
39515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39516       };
39517     } catch (Dali::DaliException e) {
39518       {
39519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39520       };
39521     } catch (...) {
39522       {
39523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39524       };
39525     }
39526   }
39527
39528 }
39529
39530
39531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39532   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39533   Dali::Vector3 *arg2 = 0 ;
39534
39535   arg1 = (Dali::CustomActorImpl *)jarg1;
39536   arg2 = (Dali::Vector3 *)jarg2;
39537   if (!arg2) {
39538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39539     return ;
39540   }
39541   {
39542     try {
39543       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39544     } catch (std::out_of_range& e) {
39545       {
39546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39547       };
39548     } catch (std::exception& e) {
39549       {
39550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39551       };
39552     } catch (Dali::DaliException e) {
39553       {
39554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39555       };
39556     } catch (...) {
39557       {
39558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39559       };
39560     }
39561   }
39562
39563 }
39564
39565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39566   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39567   Dali::Animation *arg2 = 0 ;
39568   Dali::Vector3 *arg3 = 0 ;
39569
39570   arg1 = (Dali::CustomActorImpl *)jarg1;
39571   arg2 = (Dali::Animation *)jarg2;
39572   if (!arg2) {
39573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39574     return ;
39575   }
39576   arg3 = (Dali::Vector3 *)jarg3;
39577   if (!arg3) {
39578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39579     return ;
39580   }
39581   {
39582     try {
39583       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39584     } catch (std::out_of_range& e) {
39585       {
39586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39587       };
39588     } catch (std::exception& e) {
39589       {
39590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39591       };
39592     } catch (Dali::DaliException e) {
39593       {
39594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39595       };
39596     } catch (...) {
39597       {
39598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39599       };
39600     }
39601   }
39602
39603 }
39604
39605
39606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39607   unsigned int jresult ;
39608   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39609   Dali::TouchEvent *arg2 = 0 ;
39610   bool result;
39611
39612   arg1 = (Dali::CustomActorImpl *)jarg1;
39613   arg2 = (Dali::TouchEvent *)jarg2;
39614   if (!arg2) {
39615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39616     return 0;
39617   }
39618   {
39619     try {
39620       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39621     } catch (std::out_of_range& e) {
39622       {
39623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39624       };
39625     } catch (std::exception& e) {
39626       {
39627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39628       };
39629     } catch (Dali::DaliException e) {
39630       {
39631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39632       };
39633     } catch (...) {
39634       {
39635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39636       };
39637     }
39638   }
39639
39640   jresult = result;
39641   return jresult;
39642 }
39643
39644
39645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39646   unsigned int jresult ;
39647   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39648   Dali::HoverEvent *arg2 = 0 ;
39649   bool result;
39650
39651   arg1 = (Dali::CustomActorImpl *)jarg1;
39652   arg2 = (Dali::HoverEvent *)jarg2;
39653   if (!arg2) {
39654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39655     return 0;
39656   }
39657   {
39658     try {
39659       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39660     } catch (std::out_of_range& e) {
39661       {
39662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39663       };
39664     } catch (std::exception& e) {
39665       {
39666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39667       };
39668     } catch (Dali::DaliException e) {
39669       {
39670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39671       };
39672     } catch (...) {
39673       {
39674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39675       };
39676     }
39677   }
39678
39679   jresult = result;
39680   return jresult;
39681 }
39682
39683
39684 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39685   unsigned int jresult ;
39686   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39687   Dali::KeyEvent *arg2 = 0 ;
39688   bool result;
39689
39690   arg1 = (Dali::CustomActorImpl *)jarg1;
39691   arg2 = (Dali::KeyEvent *)jarg2;
39692   if (!arg2) {
39693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39694     return 0;
39695   }
39696   {
39697     try {
39698       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39699     } catch (std::out_of_range& e) {
39700       {
39701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39702       };
39703     } catch (std::exception& e) {
39704       {
39705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39706       };
39707     } catch (Dali::DaliException e) {
39708       {
39709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39710       };
39711     } catch (...) {
39712       {
39713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39714       };
39715     }
39716   }
39717
39718   jresult = result;
39719   return jresult;
39720 }
39721
39722
39723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39724   unsigned int jresult ;
39725   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39726   Dali::WheelEvent *arg2 = 0 ;
39727   bool result;
39728
39729   arg1 = (Dali::CustomActorImpl *)jarg1;
39730   arg2 = (Dali::WheelEvent *)jarg2;
39731   if (!arg2) {
39732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39733     return 0;
39734   }
39735   {
39736     try {
39737       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39738     } catch (std::out_of_range& e) {
39739       {
39740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39741       };
39742     } catch (std::exception& e) {
39743       {
39744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39745       };
39746     } catch (Dali::DaliException e) {
39747       {
39748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39749       };
39750     } catch (...) {
39751       {
39752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39753       };
39754     }
39755   }
39756
39757   jresult = result;
39758   return jresult;
39759 }
39760
39761
39762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39763   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39764   Dali::Vector2 *arg2 = 0 ;
39765   Dali::RelayoutContainer *arg3 = 0 ;
39766
39767   arg1 = (Dali::CustomActorImpl *)jarg1;
39768   arg2 = (Dali::Vector2 *)jarg2;
39769   if (!arg2) {
39770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39771     return ;
39772   }
39773   arg3 = (Dali::RelayoutContainer *)jarg3;
39774   if (!arg3) {
39775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39776     return ;
39777   }
39778   {
39779     try {
39780       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39781     } catch (std::out_of_range& e) {
39782       {
39783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39784       };
39785     } catch (std::exception& e) {
39786       {
39787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39788       };
39789     } catch (Dali::DaliException e) {
39790       {
39791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39792       };
39793     } catch (...) {
39794       {
39795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39796       };
39797     }
39798   }
39799
39800 }
39801
39802
39803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39804   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39805   Dali::ResizePolicy::Type arg2 ;
39806   Dali::Dimension::Type arg3 ;
39807
39808   arg1 = (Dali::CustomActorImpl *)jarg1;
39809   arg2 = (Dali::ResizePolicy::Type)jarg2;
39810   arg3 = (Dali::Dimension::Type)jarg3;
39811   {
39812     try {
39813       (arg1)->OnSetResizePolicy(arg2,arg3);
39814     } catch (std::out_of_range& e) {
39815       {
39816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39817       };
39818     } catch (std::exception& e) {
39819       {
39820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39821       };
39822     } catch (Dali::DaliException e) {
39823       {
39824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39825       };
39826     } catch (...) {
39827       {
39828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39829       };
39830     }
39831   }
39832
39833 }
39834
39835
39836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39837   void * jresult ;
39838   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39839   Dali::Vector3 result;
39840
39841   arg1 = (Dali::CustomActorImpl *)jarg1;
39842   {
39843     try {
39844       result = (arg1)->GetNaturalSize();
39845     } catch (std::out_of_range& e) {
39846       {
39847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39848       };
39849     } catch (std::exception& e) {
39850       {
39851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39852       };
39853     } catch (Dali::DaliException e) {
39854       {
39855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39856       };
39857     } catch (...) {
39858       {
39859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39860       };
39861     }
39862   }
39863
39864   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39865   return jresult;
39866 }
39867
39868
39869 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39870   float jresult ;
39871   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39872   Dali::Actor *arg2 = 0 ;
39873   Dali::Dimension::Type arg3 ;
39874   float result;
39875
39876   arg1 = (Dali::CustomActorImpl *)jarg1;
39877   arg2 = (Dali::Actor *)jarg2;
39878   if (!arg2) {
39879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39880     return 0;
39881   }
39882   arg3 = (Dali::Dimension::Type)jarg3;
39883   {
39884     try {
39885       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39886     } catch (std::out_of_range& e) {
39887       {
39888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39889       };
39890     } catch (std::exception& e) {
39891       {
39892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39893       };
39894     } catch (Dali::DaliException e) {
39895       {
39896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39897       };
39898     } catch (...) {
39899       {
39900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39901       };
39902     }
39903   }
39904
39905   jresult = result;
39906   return jresult;
39907 }
39908
39909
39910 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39911   float jresult ;
39912   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39913   float arg2 ;
39914   float result;
39915
39916   arg1 = (Dali::CustomActorImpl *)jarg1;
39917   arg2 = (float)jarg2;
39918   {
39919     try {
39920       result = (float)(arg1)->GetHeightForWidth(arg2);
39921     } catch (std::out_of_range& e) {
39922       {
39923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39924       };
39925     } catch (std::exception& e) {
39926       {
39927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39928       };
39929     } catch (Dali::DaliException e) {
39930       {
39931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39932       };
39933     } catch (...) {
39934       {
39935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39936       };
39937     }
39938   }
39939
39940   jresult = result;
39941   return jresult;
39942 }
39943
39944
39945 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39946   float jresult ;
39947   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39948   float arg2 ;
39949   float result;
39950
39951   arg1 = (Dali::CustomActorImpl *)jarg1;
39952   arg2 = (float)jarg2;
39953   {
39954     try {
39955       result = (float)(arg1)->GetWidthForHeight(arg2);
39956     } catch (std::out_of_range& e) {
39957       {
39958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39959       };
39960     } catch (std::exception& e) {
39961       {
39962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39963       };
39964     } catch (Dali::DaliException e) {
39965       {
39966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39967       };
39968     } catch (...) {
39969       {
39970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39971       };
39972     }
39973   }
39974
39975   jresult = result;
39976   return jresult;
39977 }
39978
39979
39980 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39981   unsigned int jresult ;
39982   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39983   Dali::Dimension::Type arg2 ;
39984   bool result;
39985
39986   arg1 = (Dali::CustomActorImpl *)jarg1;
39987   arg2 = (Dali::Dimension::Type)jarg2;
39988   {
39989     try {
39990       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39991     } catch (std::out_of_range& e) {
39992       {
39993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39994       };
39995     } catch (std::exception& e) {
39996       {
39997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39998       };
39999     } catch (Dali::DaliException e) {
40000       {
40001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40002       };
40003     } catch (...) {
40004       {
40005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40006       };
40007     }
40008   }
40009
40010   jresult = result;
40011   return jresult;
40012 }
40013
40014
40015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
40016   unsigned int jresult ;
40017   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40018   bool result;
40019
40020   arg1 = (Dali::CustomActorImpl *)jarg1;
40021   {
40022     try {
40023       result = (bool)(arg1)->RelayoutDependentOnChildren();
40024     } catch (std::out_of_range& e) {
40025       {
40026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40027       };
40028     } catch (std::exception& e) {
40029       {
40030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40031       };
40032     } catch (Dali::DaliException e) {
40033       {
40034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40035       };
40036     } catch (...) {
40037       {
40038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40039       };
40040     }
40041   }
40042
40043   jresult = result;
40044   return jresult;
40045 }
40046
40047
40048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
40049   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40050   Dali::Dimension::Type arg2 ;
40051
40052   arg1 = (Dali::CustomActorImpl *)jarg1;
40053   arg2 = (Dali::Dimension::Type)jarg2;
40054   {
40055     try {
40056       (arg1)->OnCalculateRelayoutSize(arg2);
40057     } catch (std::out_of_range& e) {
40058       {
40059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40060       };
40061     } catch (std::exception& e) {
40062       {
40063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40064       };
40065     } catch (Dali::DaliException e) {
40066       {
40067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40068       };
40069     } catch (...) {
40070       {
40071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40072       };
40073     }
40074   }
40075
40076 }
40077
40078
40079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
40080   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40081   float arg2 ;
40082   Dali::Dimension::Type arg3 ;
40083
40084   arg1 = (Dali::CustomActorImpl *)jarg1;
40085   arg2 = (float)jarg2;
40086   arg3 = (Dali::Dimension::Type)jarg3;
40087   {
40088     try {
40089       (arg1)->OnLayoutNegotiated(arg2,arg3);
40090     } catch (std::out_of_range& e) {
40091       {
40092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40093       };
40094     } catch (std::exception& e) {
40095       {
40096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40097       };
40098     } catch (Dali::DaliException e) {
40099       {
40100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40101       };
40102     } catch (...) {
40103       {
40104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40105       };
40106     }
40107   }
40108
40109 }
40110
40111
40112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
40113   unsigned int jresult ;
40114   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40115   bool result;
40116
40117   arg1 = (Dali::CustomActorImpl *)jarg1;
40118   {
40119     try {
40120       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
40121     } catch (std::out_of_range& e) {
40122       {
40123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40124       };
40125     } catch (std::exception& e) {
40126       {
40127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40128       };
40129     } catch (Dali::DaliException e) {
40130       {
40131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40132       };
40133     } catch (...) {
40134       {
40135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40136       };
40137     }
40138   }
40139
40140   jresult = result;
40141   return jresult;
40142 }
40143
40144
40145 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
40146   unsigned int jresult ;
40147   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40148   bool result;
40149
40150   arg1 = (Dali::CustomActorImpl *)jarg1;
40151   {
40152     try {
40153       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
40154     } catch (std::out_of_range& e) {
40155       {
40156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40157       };
40158     } catch (std::exception& e) {
40159       {
40160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40161       };
40162     } catch (Dali::DaliException e) {
40163       {
40164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40165       };
40166     } catch (...) {
40167       {
40168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40169       };
40170     }
40171   }
40172
40173   jresult = result;
40174   return jresult;
40175 }
40176
40177
40178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40179   unsigned int jresult ;
40180   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40181   bool result;
40182
40183   arg1 = (Dali::CustomActorImpl *)jarg1;
40184   {
40185     try {
40186       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40187     } catch (std::out_of_range& e) {
40188       {
40189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40190       };
40191     } catch (std::exception& e) {
40192       {
40193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40194       };
40195     } catch (Dali::DaliException e) {
40196       {
40197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40198       };
40199     } catch (...) {
40200       {
40201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40202       };
40203     }
40204   }
40205
40206   jresult = result;
40207   return jresult;
40208 }
40209
40210
40211 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40212   unsigned int jresult ;
40213   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40214   bool result;
40215
40216   arg1 = (Dali::CustomActorImpl *)jarg1;
40217   {
40218     try {
40219       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40220     } catch (std::out_of_range& e) {
40221       {
40222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40223       };
40224     } catch (std::exception& e) {
40225       {
40226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40227       };
40228     } catch (Dali::DaliException e) {
40229       {
40230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40231       };
40232     } catch (...) {
40233       {
40234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40235       };
40236     }
40237   }
40238
40239   jresult = result;
40240   return jresult;
40241 }
40242
40243
40244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40245   void * jresult ;
40246   Dali::CustomActor *result = 0 ;
40247
40248   {
40249     try {
40250       result = (Dali::CustomActor *)new Dali::CustomActor();
40251     } catch (std::out_of_range& e) {
40252       {
40253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40254       };
40255     } catch (std::exception& e) {
40256       {
40257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40258       };
40259     } catch (Dali::DaliException e) {
40260       {
40261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40262       };
40263     } catch (...) {
40264       {
40265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40266       };
40267     }
40268   }
40269
40270   jresult = (void *)result;
40271   return jresult;
40272 }
40273
40274
40275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40276   void * jresult ;
40277   Dali::BaseHandle arg1 ;
40278   Dali::BaseHandle *argp1 ;
40279   Dali::CustomActor result;
40280
40281   argp1 = (Dali::BaseHandle *)jarg1;
40282   if (!argp1) {
40283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40284     return 0;
40285   }
40286   arg1 = *argp1;
40287   {
40288     try {
40289       result = Dali::CustomActor::DownCast(arg1);
40290     } catch (std::out_of_range& e) {
40291       {
40292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40293       };
40294     } catch (std::exception& e) {
40295       {
40296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40297       };
40298     } catch (Dali::DaliException e) {
40299       {
40300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40301       };
40302     } catch (...) {
40303       {
40304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40305       };
40306     }
40307   }
40308
40309   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40310   return jresult;
40311 }
40312
40313
40314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40315   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40316
40317   arg1 = (Dali::CustomActor *)jarg1;
40318   {
40319     try {
40320       delete arg1;
40321     } catch (std::out_of_range& e) {
40322       {
40323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40324       };
40325     } catch (std::exception& e) {
40326       {
40327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40328       };
40329     } catch (Dali::DaliException e) {
40330       {
40331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40332       };
40333     } catch (...) {
40334       {
40335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40336       };
40337     }
40338   }
40339
40340 }
40341
40342
40343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40344   void * jresult ;
40345   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40346   Dali::CustomActorImpl *result = 0 ;
40347
40348   arg1 = (Dali::CustomActor *)jarg1;
40349   {
40350     try {
40351       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40352     } catch (std::out_of_range& e) {
40353       {
40354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40355       };
40356     } catch (std::exception& e) {
40357       {
40358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40359       };
40360     } catch (Dali::DaliException e) {
40361       {
40362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40363       };
40364     } catch (...) {
40365       {
40366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40367       };
40368     }
40369   }
40370
40371   jresult = (void *)result;
40372   return jresult;
40373 }
40374
40375
40376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40377   void * jresult ;
40378   Dali::CustomActorImpl *arg1 = 0 ;
40379   Dali::CustomActor *result = 0 ;
40380
40381   arg1 = (Dali::CustomActorImpl *)jarg1;
40382   if (!arg1) {
40383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40384     return 0;
40385   }
40386   {
40387     try {
40388       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40389     } catch (std::out_of_range& e) {
40390       {
40391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40392       };
40393     } catch (std::exception& e) {
40394       {
40395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40396       };
40397     } catch (Dali::DaliException e) {
40398       {
40399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40400       };
40401     } catch (...) {
40402       {
40403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40404       };
40405     }
40406   }
40407
40408   jresult = (void *)result;
40409   return jresult;
40410 }
40411
40412
40413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40414   void * jresult ;
40415   Dali::CustomActor *arg1 = 0 ;
40416   Dali::CustomActor *result = 0 ;
40417
40418   arg1 = (Dali::CustomActor *)jarg1;
40419   if (!arg1) {
40420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40421     return 0;
40422   }
40423   {
40424     try {
40425       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40426     } catch (std::out_of_range& e) {
40427       {
40428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40429       };
40430     } catch (std::exception& e) {
40431       {
40432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40433       };
40434     } catch (Dali::DaliException e) {
40435       {
40436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40437       };
40438     } catch (...) {
40439       {
40440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40441       };
40442     }
40443   }
40444
40445   jresult = (void *)result;
40446   return jresult;
40447 }
40448
40449
40450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40451   void * jresult ;
40452   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40453   Dali::CustomActor *arg2 = 0 ;
40454   Dali::CustomActor *result = 0 ;
40455
40456   arg1 = (Dali::CustomActor *)jarg1;
40457   arg2 = (Dali::CustomActor *)jarg2;
40458   if (!arg2) {
40459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40460     return 0;
40461   }
40462   {
40463     try {
40464       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40465     } catch (std::out_of_range& e) {
40466       {
40467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40468       };
40469     } catch (std::exception& e) {
40470       {
40471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40472       };
40473     } catch (Dali::DaliException e) {
40474       {
40475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40476       };
40477     } catch (...) {
40478       {
40479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40480       };
40481     }
40482   }
40483
40484   jresult = (void *)result;
40485   return jresult;
40486 }
40487
40488
40489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40490   int jresult ;
40491   int result;
40492
40493   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40494   jresult = (int)result;
40495   return jresult;
40496 }
40497
40498
40499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40500   int jresult ;
40501   int result;
40502
40503   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40504   jresult = (int)result;
40505   return jresult;
40506 }
40507
40508
40509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40510   int jresult ;
40511   int result;
40512
40513   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40514   jresult = (int)result;
40515   return jresult;
40516 }
40517
40518
40519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40520   int jresult ;
40521   int result;
40522
40523   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40524   jresult = (int)result;
40525   return jresult;
40526 }
40527
40528
40529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40530   int jresult ;
40531   int result;
40532
40533   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40534   jresult = (int)result;
40535   return jresult;
40536 }
40537
40538
40539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40540   int jresult ;
40541   int result;
40542
40543   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40544   jresult = (int)result;
40545   return jresult;
40546 }
40547
40548
40549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40550   int jresult ;
40551   int result;
40552
40553   result = (int)Dali::PanGestureDetector::Property::PANNING;
40554   jresult = (int)result;
40555   return jresult;
40556 }
40557
40558
40559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40560   void * jresult ;
40561   Dali::PanGestureDetector::Property *result = 0 ;
40562
40563   {
40564     try {
40565       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40566     } catch (std::out_of_range& e) {
40567       {
40568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40569       };
40570     } catch (std::exception& e) {
40571       {
40572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40573       };
40574     } catch (Dali::DaliException e) {
40575       {
40576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40577       };
40578     } catch (...) {
40579       {
40580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40581       };
40582     }
40583   }
40584
40585   jresult = (void *)result;
40586   return jresult;
40587 }
40588
40589
40590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40591   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40592
40593   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40594   {
40595     try {
40596       delete arg1;
40597     } catch (std::out_of_range& e) {
40598       {
40599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40600       };
40601     } catch (std::exception& e) {
40602       {
40603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40604       };
40605     } catch (Dali::DaliException e) {
40606       {
40607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40608       };
40609     } catch (...) {
40610       {
40611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40612       };
40613     }
40614   }
40615
40616 }
40617
40618
40619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40620   void * jresult ;
40621   Dali::Radian *result = 0 ;
40622
40623   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40624   jresult = (void *)result;
40625   return jresult;
40626 }
40627
40628
40629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40630   void * jresult ;
40631   Dali::Radian *result = 0 ;
40632
40633   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40634   jresult = (void *)result;
40635   return jresult;
40636 }
40637
40638
40639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40640   void * jresult ;
40641   Dali::Radian *result = 0 ;
40642
40643   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40644   jresult = (void *)result;
40645   return jresult;
40646 }
40647
40648
40649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40650   void * jresult ;
40651   Dali::Radian *result = 0 ;
40652
40653   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40654   jresult = (void *)result;
40655   return jresult;
40656 }
40657
40658
40659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40660   void * jresult ;
40661   Dali::Radian *result = 0 ;
40662
40663   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40664   jresult = (void *)result;
40665   return jresult;
40666 }
40667
40668
40669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40670   void * jresult ;
40671   Dali::Radian *result = 0 ;
40672
40673   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40674   jresult = (void *)result;
40675   return jresult;
40676 }
40677
40678
40679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40680   void * jresult ;
40681   Dali::Radian *result = 0 ;
40682
40683   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40684   jresult = (void *)result;
40685   return jresult;
40686 }
40687
40688
40689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40690   void * jresult ;
40691   Dali::PanGestureDetector *result = 0 ;
40692
40693   {
40694     try {
40695       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40696     } catch (std::out_of_range& e) {
40697       {
40698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40699       };
40700     } catch (std::exception& e) {
40701       {
40702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40703       };
40704     } catch (Dali::DaliException e) {
40705       {
40706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40707       };
40708     } catch (...) {
40709       {
40710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40711       };
40712     }
40713   }
40714
40715   jresult = (void *)result;
40716   return jresult;
40717 }
40718
40719
40720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40721   void * jresult ;
40722   Dali::PanGestureDetector result;
40723
40724   {
40725     try {
40726       result = Dali::PanGestureDetector::New();
40727     } catch (std::out_of_range& e) {
40728       {
40729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40730       };
40731     } catch (std::exception& e) {
40732       {
40733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40734       };
40735     } catch (Dali::DaliException e) {
40736       {
40737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40738       };
40739     } catch (...) {
40740       {
40741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40742       };
40743     }
40744   }
40745
40746   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40747   return jresult;
40748 }
40749
40750
40751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40752   void * jresult ;
40753   Dali::BaseHandle arg1 ;
40754   Dali::BaseHandle *argp1 ;
40755   Dali::PanGestureDetector result;
40756
40757   argp1 = (Dali::BaseHandle *)jarg1;
40758   if (!argp1) {
40759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40760     return 0;
40761   }
40762   arg1 = *argp1;
40763   {
40764     try {
40765       result = Dali::PanGestureDetector::DownCast(arg1);
40766     } catch (std::out_of_range& e) {
40767       {
40768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40769       };
40770     } catch (std::exception& e) {
40771       {
40772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40773       };
40774     } catch (Dali::DaliException e) {
40775       {
40776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40777       };
40778     } catch (...) {
40779       {
40780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40781       };
40782     }
40783   }
40784
40785   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40786   return jresult;
40787 }
40788
40789
40790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40791   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40792
40793   arg1 = (Dali::PanGestureDetector *)jarg1;
40794   {
40795     try {
40796       delete arg1;
40797     } catch (std::out_of_range& e) {
40798       {
40799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40800       };
40801     } catch (std::exception& e) {
40802       {
40803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40804       };
40805     } catch (Dali::DaliException e) {
40806       {
40807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40808       };
40809     } catch (...) {
40810       {
40811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40812       };
40813     }
40814   }
40815
40816 }
40817
40818
40819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40820   void * jresult ;
40821   Dali::PanGestureDetector *arg1 = 0 ;
40822   Dali::PanGestureDetector *result = 0 ;
40823
40824   arg1 = (Dali::PanGestureDetector *)jarg1;
40825   if (!arg1) {
40826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40827     return 0;
40828   }
40829   {
40830     try {
40831       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40832     } catch (std::out_of_range& e) {
40833       {
40834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40835       };
40836     } catch (std::exception& e) {
40837       {
40838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40839       };
40840     } catch (Dali::DaliException e) {
40841       {
40842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40843       };
40844     } catch (...) {
40845       {
40846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40847       };
40848     }
40849   }
40850
40851   jresult = (void *)result;
40852   return jresult;
40853 }
40854
40855
40856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40857   void * jresult ;
40858   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40859   Dali::PanGestureDetector *arg2 = 0 ;
40860   Dali::PanGestureDetector *result = 0 ;
40861
40862   arg1 = (Dali::PanGestureDetector *)jarg1;
40863   arg2 = (Dali::PanGestureDetector *)jarg2;
40864   if (!arg2) {
40865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40866     return 0;
40867   }
40868   {
40869     try {
40870       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40871     } catch (std::out_of_range& e) {
40872       {
40873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40874       };
40875     } catch (std::exception& e) {
40876       {
40877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40878       };
40879     } catch (Dali::DaliException e) {
40880       {
40881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40882       };
40883     } catch (...) {
40884       {
40885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40886       };
40887     }
40888   }
40889
40890   jresult = (void *)result;
40891   return jresult;
40892 }
40893
40894
40895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40896   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40897   unsigned int arg2 ;
40898
40899   arg1 = (Dali::PanGestureDetector *)jarg1;
40900   arg2 = (unsigned int)jarg2;
40901   {
40902     try {
40903       (arg1)->SetMinimumTouchesRequired(arg2);
40904     } catch (std::out_of_range& e) {
40905       {
40906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40907       };
40908     } catch (std::exception& e) {
40909       {
40910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40911       };
40912     } catch (Dali::DaliException e) {
40913       {
40914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40915       };
40916     } catch (...) {
40917       {
40918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40919       };
40920     }
40921   }
40922
40923 }
40924
40925
40926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40927   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40928   unsigned int arg2 ;
40929
40930   arg1 = (Dali::PanGestureDetector *)jarg1;
40931   arg2 = (unsigned int)jarg2;
40932   {
40933     try {
40934       (arg1)->SetMaximumTouchesRequired(arg2);
40935     } catch (std::out_of_range& e) {
40936       {
40937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40938       };
40939     } catch (std::exception& e) {
40940       {
40941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40942       };
40943     } catch (Dali::DaliException e) {
40944       {
40945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40946       };
40947     } catch (...) {
40948       {
40949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40950       };
40951     }
40952   }
40953
40954 }
40955
40956
40957 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40958   unsigned int jresult ;
40959   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40960   unsigned int result;
40961
40962   arg1 = (Dali::PanGestureDetector *)jarg1;
40963   {
40964     try {
40965       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40966     } catch (std::out_of_range& e) {
40967       {
40968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40969       };
40970     } catch (std::exception& e) {
40971       {
40972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40973       };
40974     } catch (Dali::DaliException e) {
40975       {
40976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40977       };
40978     } catch (...) {
40979       {
40980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40981       };
40982     }
40983   }
40984
40985   jresult = result;
40986   return jresult;
40987 }
40988
40989
40990 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40991   unsigned int jresult ;
40992   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40993   unsigned int result;
40994
40995   arg1 = (Dali::PanGestureDetector *)jarg1;
40996   {
40997     try {
40998       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40999     } catch (std::out_of_range& e) {
41000       {
41001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41002       };
41003     } catch (std::exception& e) {
41004       {
41005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41006       };
41007     } catch (Dali::DaliException e) {
41008       {
41009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41010       };
41011     } catch (...) {
41012       {
41013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41014       };
41015     }
41016   }
41017
41018   jresult = result;
41019   return jresult;
41020 }
41021
41022
41023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
41024   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41025   Dali::Radian arg2 ;
41026   Dali::Radian arg3 ;
41027   Dali::Radian *argp2 ;
41028   Dali::Radian *argp3 ;
41029
41030   arg1 = (Dali::PanGestureDetector *)jarg1;
41031   argp2 = (Dali::Radian *)jarg2;
41032   if (!argp2) {
41033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41034     return ;
41035   }
41036   arg2 = *argp2;
41037   argp3 = (Dali::Radian *)jarg3;
41038   if (!argp3) {
41039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41040     return ;
41041   }
41042   arg3 = *argp3;
41043   {
41044     try {
41045       (arg1)->AddAngle(arg2,arg3);
41046     } catch (std::out_of_range& e) {
41047       {
41048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41049       };
41050     } catch (std::exception& e) {
41051       {
41052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41053       };
41054     } catch (Dali::DaliException e) {
41055       {
41056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41057       };
41058     } catch (...) {
41059       {
41060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41061       };
41062     }
41063   }
41064
41065 }
41066
41067
41068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
41069   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41070   Dali::Radian arg2 ;
41071   Dali::Radian *argp2 ;
41072
41073   arg1 = (Dali::PanGestureDetector *)jarg1;
41074   argp2 = (Dali::Radian *)jarg2;
41075   if (!argp2) {
41076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41077     return ;
41078   }
41079   arg2 = *argp2;
41080   {
41081     try {
41082       (arg1)->AddAngle(arg2);
41083     } catch (std::out_of_range& e) {
41084       {
41085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41086       };
41087     } catch (std::exception& e) {
41088       {
41089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41090       };
41091     } catch (Dali::DaliException e) {
41092       {
41093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41094       };
41095     } catch (...) {
41096       {
41097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41098       };
41099     }
41100   }
41101
41102 }
41103
41104
41105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
41106   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41107   Dali::Radian arg2 ;
41108   Dali::Radian arg3 ;
41109   Dali::Radian *argp2 ;
41110   Dali::Radian *argp3 ;
41111
41112   arg1 = (Dali::PanGestureDetector *)jarg1;
41113   argp2 = (Dali::Radian *)jarg2;
41114   if (!argp2) {
41115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41116     return ;
41117   }
41118   arg2 = *argp2;
41119   argp3 = (Dali::Radian *)jarg3;
41120   if (!argp3) {
41121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41122     return ;
41123   }
41124   arg3 = *argp3;
41125   {
41126     try {
41127       (arg1)->AddDirection(arg2,arg3);
41128     } catch (std::out_of_range& e) {
41129       {
41130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41131       };
41132     } catch (std::exception& e) {
41133       {
41134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41135       };
41136     } catch (Dali::DaliException e) {
41137       {
41138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41139       };
41140     } catch (...) {
41141       {
41142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41143       };
41144     }
41145   }
41146
41147 }
41148
41149
41150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
41151   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41152   Dali::Radian arg2 ;
41153   Dali::Radian *argp2 ;
41154
41155   arg1 = (Dali::PanGestureDetector *)jarg1;
41156   argp2 = (Dali::Radian *)jarg2;
41157   if (!argp2) {
41158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41159     return ;
41160   }
41161   arg2 = *argp2;
41162   {
41163     try {
41164       (arg1)->AddDirection(arg2);
41165     } catch (std::out_of_range& e) {
41166       {
41167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41168       };
41169     } catch (std::exception& e) {
41170       {
41171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41172       };
41173     } catch (Dali::DaliException e) {
41174       {
41175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41176       };
41177     } catch (...) {
41178       {
41179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41180       };
41181     }
41182   }
41183
41184 }
41185
41186
41187 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41188   unsigned long jresult ;
41189   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41190   size_t result;
41191
41192   arg1 = (Dali::PanGestureDetector *)jarg1;
41193   {
41194     try {
41195       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41196     } catch (std::out_of_range& e) {
41197       {
41198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41199       };
41200     } catch (std::exception& e) {
41201       {
41202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41203       };
41204     } catch (Dali::DaliException e) {
41205       {
41206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41207       };
41208     } catch (...) {
41209       {
41210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41211       };
41212     }
41213   }
41214
41215   jresult = (unsigned long)result;
41216   return jresult;
41217 }
41218
41219
41220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41221   void * jresult ;
41222   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41223   size_t arg2 ;
41224   Dali::PanGestureDetector::AngleThresholdPair result;
41225
41226   arg1 = (Dali::PanGestureDetector *)jarg1;
41227   arg2 = (size_t)jarg2;
41228   {
41229     try {
41230       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41231     } catch (std::out_of_range& e) {
41232       {
41233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41234       };
41235     } catch (std::exception& e) {
41236       {
41237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41238       };
41239     } catch (Dali::DaliException e) {
41240       {
41241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41242       };
41243     } catch (...) {
41244       {
41245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41246       };
41247     }
41248   }
41249
41250   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41251   return jresult;
41252 }
41253
41254
41255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41256   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41257
41258   arg1 = (Dali::PanGestureDetector *)jarg1;
41259   {
41260     try {
41261       (arg1)->ClearAngles();
41262     } catch (std::out_of_range& e) {
41263       {
41264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41265       };
41266     } catch (std::exception& e) {
41267       {
41268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41269       };
41270     } catch (Dali::DaliException e) {
41271       {
41272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41273       };
41274     } catch (...) {
41275       {
41276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41277       };
41278     }
41279   }
41280
41281 }
41282
41283
41284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41285   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41286   Dali::Radian arg2 ;
41287   Dali::Radian *argp2 ;
41288
41289   arg1 = (Dali::PanGestureDetector *)jarg1;
41290   argp2 = (Dali::Radian *)jarg2;
41291   if (!argp2) {
41292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41293     return ;
41294   }
41295   arg2 = *argp2;
41296   {
41297     try {
41298       (arg1)->RemoveAngle(arg2);
41299     } catch (std::out_of_range& e) {
41300       {
41301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41302       };
41303     } catch (std::exception& e) {
41304       {
41305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41306       };
41307     } catch (Dali::DaliException e) {
41308       {
41309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41310       };
41311     } catch (...) {
41312       {
41313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41314       };
41315     }
41316   }
41317
41318 }
41319
41320
41321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41322   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41323   Dali::Radian arg2 ;
41324   Dali::Radian *argp2 ;
41325
41326   arg1 = (Dali::PanGestureDetector *)jarg1;
41327   argp2 = (Dali::Radian *)jarg2;
41328   if (!argp2) {
41329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41330     return ;
41331   }
41332   arg2 = *argp2;
41333   {
41334     try {
41335       (arg1)->RemoveDirection(arg2);
41336     } catch (std::out_of_range& e) {
41337       {
41338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41339       };
41340     } catch (std::exception& e) {
41341       {
41342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41343       };
41344     } catch (Dali::DaliException e) {
41345       {
41346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41347       };
41348     } catch (...) {
41349       {
41350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41351       };
41352     }
41353   }
41354
41355 }
41356
41357
41358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41359   void * jresult ;
41360   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41361   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41362
41363   arg1 = (Dali::PanGestureDetector *)jarg1;
41364   {
41365     try {
41366       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41367     } catch (std::out_of_range& e) {
41368       {
41369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41370       };
41371     } catch (std::exception& e) {
41372       {
41373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41374       };
41375     } catch (Dali::DaliException e) {
41376       {
41377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41378       };
41379     } catch (...) {
41380       {
41381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41382       };
41383     }
41384   }
41385
41386   jresult = (void *)result;
41387   return jresult;
41388 }
41389
41390
41391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41392   Dali::PanGesture *arg1 = 0 ;
41393
41394   arg1 = (Dali::PanGesture *)jarg1;
41395   if (!arg1) {
41396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41397     return ;
41398   }
41399   {
41400     try {
41401       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41402     } catch (std::out_of_range& e) {
41403       {
41404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41405       };
41406     } catch (std::exception& e) {
41407       {
41408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41409       };
41410     } catch (Dali::DaliException e) {
41411       {
41412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41413       };
41414     } catch (...) {
41415       {
41416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41417       };
41418     }
41419   }
41420
41421 }
41422
41423
41424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41425   void * jresult ;
41426   Dali::PanGesture *result = 0 ;
41427
41428   {
41429     try {
41430       result = (Dali::PanGesture *)new Dali::PanGesture();
41431     } catch (std::out_of_range& e) {
41432       {
41433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41434       };
41435     } catch (std::exception& e) {
41436       {
41437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41438       };
41439     } catch (Dali::DaliException e) {
41440       {
41441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41442       };
41443     } catch (...) {
41444       {
41445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41446       };
41447     }
41448   }
41449
41450   jresult = (void *)result;
41451   return jresult;
41452 }
41453
41454
41455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41456   void * jresult ;
41457   Dali::Gesture::State arg1 ;
41458   Dali::PanGesture *result = 0 ;
41459
41460   arg1 = (Dali::Gesture::State)jarg1;
41461   {
41462     try {
41463       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41464     } catch (std::out_of_range& e) {
41465       {
41466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41467       };
41468     } catch (std::exception& e) {
41469       {
41470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41471       };
41472     } catch (Dali::DaliException e) {
41473       {
41474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41475       };
41476     } catch (...) {
41477       {
41478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41479       };
41480     }
41481   }
41482
41483   jresult = (void *)result;
41484   return jresult;
41485 }
41486
41487
41488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41489   void * jresult ;
41490   Dali::PanGesture *arg1 = 0 ;
41491   Dali::PanGesture *result = 0 ;
41492
41493   arg1 = (Dali::PanGesture *)jarg1;
41494   if (!arg1) {
41495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41496     return 0;
41497   }
41498   {
41499     try {
41500       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41501     } catch (std::out_of_range& e) {
41502       {
41503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41504       };
41505     } catch (std::exception& e) {
41506       {
41507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41508       };
41509     } catch (Dali::DaliException e) {
41510       {
41511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41512       };
41513     } catch (...) {
41514       {
41515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41516       };
41517     }
41518   }
41519
41520   jresult = (void *)result;
41521   return jresult;
41522 }
41523
41524
41525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41526   void * jresult ;
41527   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41528   Dali::PanGesture *arg2 = 0 ;
41529   Dali::PanGesture *result = 0 ;
41530
41531   arg1 = (Dali::PanGesture *)jarg1;
41532   arg2 = (Dali::PanGesture *)jarg2;
41533   if (!arg2) {
41534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41535     return 0;
41536   }
41537   {
41538     try {
41539       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41540     } catch (std::out_of_range& e) {
41541       {
41542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41543       };
41544     } catch (std::exception& e) {
41545       {
41546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41547       };
41548     } catch (Dali::DaliException e) {
41549       {
41550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41551       };
41552     } catch (...) {
41553       {
41554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41555       };
41556     }
41557   }
41558
41559   jresult = (void *)result;
41560   return jresult;
41561 }
41562
41563
41564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41565   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41566
41567   arg1 = (Dali::PanGesture *)jarg1;
41568   {
41569     try {
41570       delete arg1;
41571     } catch (std::out_of_range& e) {
41572       {
41573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41574       };
41575     } catch (std::exception& e) {
41576       {
41577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41578       };
41579     } catch (Dali::DaliException e) {
41580       {
41581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41582       };
41583     } catch (...) {
41584       {
41585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41586       };
41587     }
41588   }
41589
41590 }
41591
41592
41593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41594   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41595   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41596
41597   arg1 = (Dali::PanGesture *)jarg1;
41598   arg2 = (Dali::Vector2 *)jarg2;
41599   if (arg1) (arg1)->velocity = *arg2;
41600 }
41601
41602
41603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41604   void * jresult ;
41605   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41606   Dali::Vector2 *result = 0 ;
41607
41608   arg1 = (Dali::PanGesture *)jarg1;
41609   result = (Dali::Vector2 *)& ((arg1)->velocity);
41610   jresult = (void *)result;
41611   return jresult;
41612 }
41613
41614
41615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41616   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41617   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41618
41619   arg1 = (Dali::PanGesture *)jarg1;
41620   arg2 = (Dali::Vector2 *)jarg2;
41621   if (arg1) (arg1)->displacement = *arg2;
41622 }
41623
41624
41625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41626   void * jresult ;
41627   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41628   Dali::Vector2 *result = 0 ;
41629
41630   arg1 = (Dali::PanGesture *)jarg1;
41631   result = (Dali::Vector2 *)& ((arg1)->displacement);
41632   jresult = (void *)result;
41633   return jresult;
41634 }
41635
41636
41637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41638   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41639   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41640
41641   arg1 = (Dali::PanGesture *)jarg1;
41642   arg2 = (Dali::Vector2 *)jarg2;
41643   if (arg1) (arg1)->position = *arg2;
41644 }
41645
41646
41647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41648   void * jresult ;
41649   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41650   Dali::Vector2 *result = 0 ;
41651
41652   arg1 = (Dali::PanGesture *)jarg1;
41653   result = (Dali::Vector2 *)& ((arg1)->position);
41654   jresult = (void *)result;
41655   return jresult;
41656 }
41657
41658
41659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41660   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41661   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41662
41663   arg1 = (Dali::PanGesture *)jarg1;
41664   arg2 = (Dali::Vector2 *)jarg2;
41665   if (arg1) (arg1)->screenVelocity = *arg2;
41666 }
41667
41668
41669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41670   void * jresult ;
41671   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41672   Dali::Vector2 *result = 0 ;
41673
41674   arg1 = (Dali::PanGesture *)jarg1;
41675   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41676   jresult = (void *)result;
41677   return jresult;
41678 }
41679
41680
41681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41682   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41683   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41684
41685   arg1 = (Dali::PanGesture *)jarg1;
41686   arg2 = (Dali::Vector2 *)jarg2;
41687   if (arg1) (arg1)->screenDisplacement = *arg2;
41688 }
41689
41690
41691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41692   void * jresult ;
41693   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41694   Dali::Vector2 *result = 0 ;
41695
41696   arg1 = (Dali::PanGesture *)jarg1;
41697   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41698   jresult = (void *)result;
41699   return jresult;
41700 }
41701
41702
41703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41704   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41705   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41706
41707   arg1 = (Dali::PanGesture *)jarg1;
41708   arg2 = (Dali::Vector2 *)jarg2;
41709   if (arg1) (arg1)->screenPosition = *arg2;
41710 }
41711
41712
41713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41714   void * jresult ;
41715   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41716   Dali::Vector2 *result = 0 ;
41717
41718   arg1 = (Dali::PanGesture *)jarg1;
41719   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41720   jresult = (void *)result;
41721   return jresult;
41722 }
41723
41724
41725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41726   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41727   unsigned int arg2 ;
41728
41729   arg1 = (Dali::PanGesture *)jarg1;
41730   arg2 = (unsigned int)jarg2;
41731   if (arg1) (arg1)->numberOfTouches = arg2;
41732 }
41733
41734
41735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41736   unsigned int jresult ;
41737   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41738   unsigned int result;
41739
41740   arg1 = (Dali::PanGesture *)jarg1;
41741   result = (unsigned int) ((arg1)->numberOfTouches);
41742   jresult = result;
41743   return jresult;
41744 }
41745
41746
41747 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41748   float jresult ;
41749   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41750   float result;
41751
41752   arg1 = (Dali::PanGesture *)jarg1;
41753   {
41754     try {
41755       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41756     } catch (std::out_of_range& e) {
41757       {
41758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41759       };
41760     } catch (std::exception& e) {
41761       {
41762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41763       };
41764     } catch (Dali::DaliException e) {
41765       {
41766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41767       };
41768     } catch (...) {
41769       {
41770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41771       };
41772     }
41773   }
41774
41775   jresult = result;
41776   return jresult;
41777 }
41778
41779
41780 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41781   float jresult ;
41782   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41783   float result;
41784
41785   arg1 = (Dali::PanGesture *)jarg1;
41786   {
41787     try {
41788       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41789     } catch (std::out_of_range& e) {
41790       {
41791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41792       };
41793     } catch (std::exception& e) {
41794       {
41795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41796       };
41797     } catch (Dali::DaliException e) {
41798       {
41799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41800       };
41801     } catch (...) {
41802       {
41803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41804       };
41805     }
41806   }
41807
41808   jresult = result;
41809   return jresult;
41810 }
41811
41812
41813 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41814   float jresult ;
41815   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41816   float result;
41817
41818   arg1 = (Dali::PanGesture *)jarg1;
41819   {
41820     try {
41821       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41822     } catch (std::out_of_range& e) {
41823       {
41824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41825       };
41826     } catch (std::exception& e) {
41827       {
41828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41829       };
41830     } catch (Dali::DaliException e) {
41831       {
41832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41833       };
41834     } catch (...) {
41835       {
41836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41837       };
41838     }
41839   }
41840
41841   jresult = result;
41842   return jresult;
41843 }
41844
41845
41846 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41847   float jresult ;
41848   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41849   float result;
41850
41851   arg1 = (Dali::PanGesture *)jarg1;
41852   {
41853     try {
41854       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41855     } catch (std::out_of_range& e) {
41856       {
41857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41858       };
41859     } catch (std::exception& e) {
41860       {
41861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41862       };
41863     } catch (Dali::DaliException e) {
41864       {
41865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41866       };
41867     } catch (...) {
41868       {
41869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41870       };
41871     }
41872   }
41873
41874   jresult = result;
41875   return jresult;
41876 }
41877
41878
41879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41880   void * jresult ;
41881   Dali::PinchGestureDetector *result = 0 ;
41882
41883   {
41884     try {
41885       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41886     } catch (std::out_of_range& e) {
41887       {
41888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41889       };
41890     } catch (std::exception& e) {
41891       {
41892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41893       };
41894     } catch (Dali::DaliException e) {
41895       {
41896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41897       };
41898     } catch (...) {
41899       {
41900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41901       };
41902     }
41903   }
41904
41905   jresult = (void *)result;
41906   return jresult;
41907 }
41908
41909
41910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41911   void * jresult ;
41912   Dali::PinchGestureDetector result;
41913
41914   {
41915     try {
41916       result = Dali::PinchGestureDetector::New();
41917     } catch (std::out_of_range& e) {
41918       {
41919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41920       };
41921     } catch (std::exception& e) {
41922       {
41923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41924       };
41925     } catch (Dali::DaliException e) {
41926       {
41927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41928       };
41929     } catch (...) {
41930       {
41931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41932       };
41933     }
41934   }
41935
41936   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41937   return jresult;
41938 }
41939
41940
41941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41942   void * jresult ;
41943   Dali::BaseHandle arg1 ;
41944   Dali::BaseHandle *argp1 ;
41945   Dali::PinchGestureDetector result;
41946
41947   argp1 = (Dali::BaseHandle *)jarg1;
41948   if (!argp1) {
41949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41950     return 0;
41951   }
41952   arg1 = *argp1;
41953   {
41954     try {
41955       result = Dali::PinchGestureDetector::DownCast(arg1);
41956     } catch (std::out_of_range& e) {
41957       {
41958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41959       };
41960     } catch (std::exception& e) {
41961       {
41962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41963       };
41964     } catch (Dali::DaliException e) {
41965       {
41966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41967       };
41968     } catch (...) {
41969       {
41970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41971       };
41972     }
41973   }
41974
41975   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41976   return jresult;
41977 }
41978
41979
41980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41981   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41982
41983   arg1 = (Dali::PinchGestureDetector *)jarg1;
41984   {
41985     try {
41986       delete arg1;
41987     } catch (std::out_of_range& e) {
41988       {
41989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41990       };
41991     } catch (std::exception& e) {
41992       {
41993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41994       };
41995     } catch (Dali::DaliException e) {
41996       {
41997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41998       };
41999     } catch (...) {
42000       {
42001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42002       };
42003     }
42004   }
42005
42006 }
42007
42008
42009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
42010   void * jresult ;
42011   Dali::PinchGestureDetector *arg1 = 0 ;
42012   Dali::PinchGestureDetector *result = 0 ;
42013
42014   arg1 = (Dali::PinchGestureDetector *)jarg1;
42015   if (!arg1) {
42016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
42017     return 0;
42018   }
42019   {
42020     try {
42021       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
42022     } catch (std::out_of_range& e) {
42023       {
42024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42025       };
42026     } catch (std::exception& e) {
42027       {
42028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42029       };
42030     } catch (Dali::DaliException e) {
42031       {
42032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42033       };
42034     } catch (...) {
42035       {
42036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42037       };
42038     }
42039   }
42040
42041   jresult = (void *)result;
42042   return jresult;
42043 }
42044
42045
42046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
42047   void * jresult ;
42048   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
42049   Dali::PinchGestureDetector *arg2 = 0 ;
42050   Dali::PinchGestureDetector *result = 0 ;
42051
42052   arg1 = (Dali::PinchGestureDetector *)jarg1;
42053   arg2 = (Dali::PinchGestureDetector *)jarg2;
42054   if (!arg2) {
42055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
42056     return 0;
42057   }
42058   {
42059     try {
42060       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
42061     } catch (std::out_of_range& e) {
42062       {
42063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42064       };
42065     } catch (std::exception& e) {
42066       {
42067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42068       };
42069     } catch (Dali::DaliException e) {
42070       {
42071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42072       };
42073     } catch (...) {
42074       {
42075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42076       };
42077     }
42078   }
42079
42080   jresult = (void *)result;
42081   return jresult;
42082 }
42083
42084
42085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
42086   void * jresult ;
42087   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
42088   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
42089
42090   arg1 = (Dali::PinchGestureDetector *)jarg1;
42091   {
42092     try {
42093       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42094     } catch (std::out_of_range& e) {
42095       {
42096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42097       };
42098     } catch (std::exception& e) {
42099       {
42100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42101       };
42102     } catch (Dali::DaliException e) {
42103       {
42104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42105       };
42106     } catch (...) {
42107       {
42108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42109       };
42110     }
42111   }
42112
42113   jresult = (void *)result;
42114   return jresult;
42115 }
42116
42117
42118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
42119   void * jresult ;
42120   Dali::Gesture::State arg1 ;
42121   Dali::PinchGesture *result = 0 ;
42122
42123   arg1 = (Dali::Gesture::State)jarg1;
42124   {
42125     try {
42126       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
42127     } catch (std::out_of_range& e) {
42128       {
42129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42130       };
42131     } catch (std::exception& e) {
42132       {
42133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42134       };
42135     } catch (Dali::DaliException e) {
42136       {
42137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42138       };
42139     } catch (...) {
42140       {
42141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42142       };
42143     }
42144   }
42145
42146   jresult = (void *)result;
42147   return jresult;
42148 }
42149
42150
42151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
42152   void * jresult ;
42153   Dali::PinchGesture *arg1 = 0 ;
42154   Dali::PinchGesture *result = 0 ;
42155
42156   arg1 = (Dali::PinchGesture *)jarg1;
42157   if (!arg1) {
42158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42159     return 0;
42160   }
42161   {
42162     try {
42163       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
42164     } catch (std::out_of_range& e) {
42165       {
42166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42167       };
42168     } catch (std::exception& e) {
42169       {
42170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42171       };
42172     } catch (Dali::DaliException e) {
42173       {
42174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42175       };
42176     } catch (...) {
42177       {
42178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42179       };
42180     }
42181   }
42182
42183   jresult = (void *)result;
42184   return jresult;
42185 }
42186
42187
42188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42189   void * jresult ;
42190   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42191   Dali::PinchGesture *arg2 = 0 ;
42192   Dali::PinchGesture *result = 0 ;
42193
42194   arg1 = (Dali::PinchGesture *)jarg1;
42195   arg2 = (Dali::PinchGesture *)jarg2;
42196   if (!arg2) {
42197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42198     return 0;
42199   }
42200   {
42201     try {
42202       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42203     } catch (std::out_of_range& e) {
42204       {
42205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42206       };
42207     } catch (std::exception& e) {
42208       {
42209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42210       };
42211     } catch (Dali::DaliException e) {
42212       {
42213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42214       };
42215     } catch (...) {
42216       {
42217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42218       };
42219     }
42220   }
42221
42222   jresult = (void *)result;
42223   return jresult;
42224 }
42225
42226
42227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42228   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42229
42230   arg1 = (Dali::PinchGesture *)jarg1;
42231   {
42232     try {
42233       delete arg1;
42234     } catch (std::out_of_range& e) {
42235       {
42236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42237       };
42238     } catch (std::exception& e) {
42239       {
42240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42241       };
42242     } catch (Dali::DaliException e) {
42243       {
42244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42245       };
42246     } catch (...) {
42247       {
42248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42249       };
42250     }
42251   }
42252
42253 }
42254
42255
42256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42257   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42258   float arg2 ;
42259
42260   arg1 = (Dali::PinchGesture *)jarg1;
42261   arg2 = (float)jarg2;
42262   if (arg1) (arg1)->scale = arg2;
42263 }
42264
42265
42266 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42267   float jresult ;
42268   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42269   float result;
42270
42271   arg1 = (Dali::PinchGesture *)jarg1;
42272   result = (float) ((arg1)->scale);
42273   jresult = result;
42274   return jresult;
42275 }
42276
42277
42278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42279   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42280   float arg2 ;
42281
42282   arg1 = (Dali::PinchGesture *)jarg1;
42283   arg2 = (float)jarg2;
42284   if (arg1) (arg1)->speed = arg2;
42285 }
42286
42287
42288 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42289   float jresult ;
42290   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42291   float result;
42292
42293   arg1 = (Dali::PinchGesture *)jarg1;
42294   result = (float) ((arg1)->speed);
42295   jresult = result;
42296   return jresult;
42297 }
42298
42299
42300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42301   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42302   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42303
42304   arg1 = (Dali::PinchGesture *)jarg1;
42305   arg2 = (Dali::Vector2 *)jarg2;
42306   if (arg1) (arg1)->screenCenterPoint = *arg2;
42307 }
42308
42309
42310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42311   void * jresult ;
42312   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42313   Dali::Vector2 *result = 0 ;
42314
42315   arg1 = (Dali::PinchGesture *)jarg1;
42316   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42317   jresult = (void *)result;
42318   return jresult;
42319 }
42320
42321
42322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42323   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42324   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42325
42326   arg1 = (Dali::PinchGesture *)jarg1;
42327   arg2 = (Dali::Vector2 *)jarg2;
42328   if (arg1) (arg1)->localCenterPoint = *arg2;
42329 }
42330
42331
42332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42333   void * jresult ;
42334   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42335   Dali::Vector2 *result = 0 ;
42336
42337   arg1 = (Dali::PinchGesture *)jarg1;
42338   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42339   jresult = (void *)result;
42340   return jresult;
42341 }
42342
42343
42344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42345   void * jresult ;
42346   Dali::TapGestureDetector *result = 0 ;
42347
42348   {
42349     try {
42350       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42351     } catch (std::out_of_range& e) {
42352       {
42353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42354       };
42355     } catch (std::exception& e) {
42356       {
42357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42358       };
42359     } catch (Dali::DaliException e) {
42360       {
42361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42362       };
42363     } catch (...) {
42364       {
42365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42366       };
42367     }
42368   }
42369
42370   jresult = (void *)result;
42371   return jresult;
42372 }
42373
42374
42375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42376   void * jresult ;
42377   Dali::TapGestureDetector result;
42378
42379   {
42380     try {
42381       result = Dali::TapGestureDetector::New();
42382     } catch (std::out_of_range& e) {
42383       {
42384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42385       };
42386     } catch (std::exception& e) {
42387       {
42388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42389       };
42390     } catch (Dali::DaliException e) {
42391       {
42392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42393       };
42394     } catch (...) {
42395       {
42396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42397       };
42398     }
42399   }
42400
42401   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42402   return jresult;
42403 }
42404
42405
42406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42407   void * jresult ;
42408   unsigned int arg1 ;
42409   Dali::TapGestureDetector result;
42410
42411   arg1 = (unsigned int)jarg1;
42412   {
42413     try {
42414       result = Dali::TapGestureDetector::New(arg1);
42415     } catch (std::out_of_range& e) {
42416       {
42417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42418       };
42419     } catch (std::exception& e) {
42420       {
42421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42422       };
42423     } catch (Dali::DaliException e) {
42424       {
42425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42426       };
42427     } catch (...) {
42428       {
42429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42430       };
42431     }
42432   }
42433
42434   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42435   return jresult;
42436 }
42437
42438
42439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42440   void * jresult ;
42441   Dali::BaseHandle arg1 ;
42442   Dali::BaseHandle *argp1 ;
42443   Dali::TapGestureDetector result;
42444
42445   argp1 = (Dali::BaseHandle *)jarg1;
42446   if (!argp1) {
42447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42448     return 0;
42449   }
42450   arg1 = *argp1;
42451   {
42452     try {
42453       result = Dali::TapGestureDetector::DownCast(arg1);
42454     } catch (std::out_of_range& e) {
42455       {
42456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42457       };
42458     } catch (std::exception& e) {
42459       {
42460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42461       };
42462     } catch (Dali::DaliException e) {
42463       {
42464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42465       };
42466     } catch (...) {
42467       {
42468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42469       };
42470     }
42471   }
42472
42473   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42474   return jresult;
42475 }
42476
42477
42478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42479   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42480
42481   arg1 = (Dali::TapGestureDetector *)jarg1;
42482   {
42483     try {
42484       delete arg1;
42485     } catch (std::out_of_range& e) {
42486       {
42487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42488       };
42489     } catch (std::exception& e) {
42490       {
42491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42492       };
42493     } catch (Dali::DaliException e) {
42494       {
42495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42496       };
42497     } catch (...) {
42498       {
42499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42500       };
42501     }
42502   }
42503
42504 }
42505
42506
42507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42508   void * jresult ;
42509   Dali::TapGestureDetector *arg1 = 0 ;
42510   Dali::TapGestureDetector *result = 0 ;
42511
42512   arg1 = (Dali::TapGestureDetector *)jarg1;
42513   if (!arg1) {
42514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42515     return 0;
42516   }
42517   {
42518     try {
42519       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42520     } catch (std::out_of_range& e) {
42521       {
42522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42523       };
42524     } catch (std::exception& e) {
42525       {
42526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42527       };
42528     } catch (Dali::DaliException e) {
42529       {
42530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42531       };
42532     } catch (...) {
42533       {
42534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42535       };
42536     }
42537   }
42538
42539   jresult = (void *)result;
42540   return jresult;
42541 }
42542
42543
42544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42545   void * jresult ;
42546   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42547   Dali::TapGestureDetector *arg2 = 0 ;
42548   Dali::TapGestureDetector *result = 0 ;
42549
42550   arg1 = (Dali::TapGestureDetector *)jarg1;
42551   arg2 = (Dali::TapGestureDetector *)jarg2;
42552   if (!arg2) {
42553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42554     return 0;
42555   }
42556   {
42557     try {
42558       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42559     } catch (std::out_of_range& e) {
42560       {
42561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42562       };
42563     } catch (std::exception& e) {
42564       {
42565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42566       };
42567     } catch (Dali::DaliException e) {
42568       {
42569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42570       };
42571     } catch (...) {
42572       {
42573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42574       };
42575     }
42576   }
42577
42578   jresult = (void *)result;
42579   return jresult;
42580 }
42581
42582
42583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42584   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42585   unsigned int arg2 ;
42586
42587   arg1 = (Dali::TapGestureDetector *)jarg1;
42588   arg2 = (unsigned int)jarg2;
42589   {
42590     try {
42591       (arg1)->SetMinimumTapsRequired(arg2);
42592     } catch (std::out_of_range& e) {
42593       {
42594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42595       };
42596     } catch (std::exception& e) {
42597       {
42598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42599       };
42600     } catch (Dali::DaliException e) {
42601       {
42602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42603       };
42604     } catch (...) {
42605       {
42606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42607       };
42608     }
42609   }
42610
42611 }
42612
42613
42614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42615   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42616   unsigned int arg2 ;
42617
42618   arg1 = (Dali::TapGestureDetector *)jarg1;
42619   arg2 = (unsigned int)jarg2;
42620   {
42621     try {
42622       (arg1)->SetMaximumTapsRequired(arg2);
42623     } catch (std::out_of_range& e) {
42624       {
42625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42626       };
42627     } catch (std::exception& e) {
42628       {
42629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42630       };
42631     } catch (Dali::DaliException e) {
42632       {
42633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42634       };
42635     } catch (...) {
42636       {
42637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42638       };
42639     }
42640   }
42641
42642 }
42643
42644
42645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42646   unsigned int jresult ;
42647   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42648   unsigned int result;
42649
42650   arg1 = (Dali::TapGestureDetector *)jarg1;
42651   {
42652     try {
42653       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42654     } catch (std::out_of_range& e) {
42655       {
42656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42657       };
42658     } catch (std::exception& e) {
42659       {
42660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42661       };
42662     } catch (Dali::DaliException e) {
42663       {
42664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42665       };
42666     } catch (...) {
42667       {
42668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42669       };
42670     }
42671   }
42672
42673   jresult = result;
42674   return jresult;
42675 }
42676
42677
42678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42679   unsigned int jresult ;
42680   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42681   unsigned int result;
42682
42683   arg1 = (Dali::TapGestureDetector *)jarg1;
42684   {
42685     try {
42686       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42687     } catch (std::out_of_range& e) {
42688       {
42689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42690       };
42691     } catch (std::exception& e) {
42692       {
42693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42694       };
42695     } catch (Dali::DaliException e) {
42696       {
42697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42698       };
42699     } catch (...) {
42700       {
42701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42702       };
42703     }
42704   }
42705
42706   jresult = result;
42707   return jresult;
42708 }
42709
42710
42711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42712   void * jresult ;
42713   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42714   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42715
42716   arg1 = (Dali::TapGestureDetector *)jarg1;
42717   {
42718     try {
42719       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42720     } catch (std::out_of_range& e) {
42721       {
42722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42723       };
42724     } catch (std::exception& e) {
42725       {
42726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42727       };
42728     } catch (Dali::DaliException e) {
42729       {
42730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42731       };
42732     } catch (...) {
42733       {
42734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42735       };
42736     }
42737   }
42738
42739   jresult = (void *)result;
42740   return jresult;
42741 }
42742
42743
42744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42745   void * jresult ;
42746   Dali::TapGesture *result = 0 ;
42747
42748   {
42749     try {
42750       result = (Dali::TapGesture *)new Dali::TapGesture();
42751     } catch (std::out_of_range& e) {
42752       {
42753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42754       };
42755     } catch (std::exception& e) {
42756       {
42757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42758       };
42759     } catch (Dali::DaliException e) {
42760       {
42761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42762       };
42763     } catch (...) {
42764       {
42765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42766       };
42767     }
42768   }
42769
42770   jresult = (void *)result;
42771   return jresult;
42772 }
42773
42774
42775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42776   void * jresult ;
42777   Dali::TapGesture *arg1 = 0 ;
42778   Dali::TapGesture *result = 0 ;
42779
42780   arg1 = (Dali::TapGesture *)jarg1;
42781   if (!arg1) {
42782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42783     return 0;
42784   }
42785   {
42786     try {
42787       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42788     } catch (std::out_of_range& e) {
42789       {
42790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42791       };
42792     } catch (std::exception& e) {
42793       {
42794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42795       };
42796     } catch (Dali::DaliException e) {
42797       {
42798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42799       };
42800     } catch (...) {
42801       {
42802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42803       };
42804     }
42805   }
42806
42807   jresult = (void *)result;
42808   return jresult;
42809 }
42810
42811
42812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42813   void * jresult ;
42814   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42815   Dali::TapGesture *arg2 = 0 ;
42816   Dali::TapGesture *result = 0 ;
42817
42818   arg1 = (Dali::TapGesture *)jarg1;
42819   arg2 = (Dali::TapGesture *)jarg2;
42820   if (!arg2) {
42821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42822     return 0;
42823   }
42824   {
42825     try {
42826       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42827     } catch (std::out_of_range& e) {
42828       {
42829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42830       };
42831     } catch (std::exception& e) {
42832       {
42833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42834       };
42835     } catch (Dali::DaliException e) {
42836       {
42837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42838       };
42839     } catch (...) {
42840       {
42841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42842       };
42843     }
42844   }
42845
42846   jresult = (void *)result;
42847   return jresult;
42848 }
42849
42850
42851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42852   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42853
42854   arg1 = (Dali::TapGesture *)jarg1;
42855   {
42856     try {
42857       delete arg1;
42858     } catch (std::out_of_range& e) {
42859       {
42860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42861       };
42862     } catch (std::exception& e) {
42863       {
42864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42865       };
42866     } catch (Dali::DaliException e) {
42867       {
42868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42869       };
42870     } catch (...) {
42871       {
42872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42873       };
42874     }
42875   }
42876
42877 }
42878
42879
42880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42881   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42882   unsigned int arg2 ;
42883
42884   arg1 = (Dali::TapGesture *)jarg1;
42885   arg2 = (unsigned int)jarg2;
42886   if (arg1) (arg1)->numberOfTaps = arg2;
42887 }
42888
42889
42890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42891   unsigned int jresult ;
42892   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42893   unsigned int result;
42894
42895   arg1 = (Dali::TapGesture *)jarg1;
42896   result = (unsigned int) ((arg1)->numberOfTaps);
42897   jresult = result;
42898   return jresult;
42899 }
42900
42901
42902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42903   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42904   unsigned int arg2 ;
42905
42906   arg1 = (Dali::TapGesture *)jarg1;
42907   arg2 = (unsigned int)jarg2;
42908   if (arg1) (arg1)->numberOfTouches = arg2;
42909 }
42910
42911
42912 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42913   unsigned int jresult ;
42914   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42915   unsigned int result;
42916
42917   arg1 = (Dali::TapGesture *)jarg1;
42918   result = (unsigned int) ((arg1)->numberOfTouches);
42919   jresult = result;
42920   return jresult;
42921 }
42922
42923
42924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42925   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42926   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42927
42928   arg1 = (Dali::TapGesture *)jarg1;
42929   arg2 = (Dali::Vector2 *)jarg2;
42930   if (arg1) (arg1)->screenPoint = *arg2;
42931 }
42932
42933
42934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42935   void * jresult ;
42936   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42937   Dali::Vector2 *result = 0 ;
42938
42939   arg1 = (Dali::TapGesture *)jarg1;
42940   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42941   jresult = (void *)result;
42942   return jresult;
42943 }
42944
42945
42946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42947   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42948   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42949
42950   arg1 = (Dali::TapGesture *)jarg1;
42951   arg2 = (Dali::Vector2 *)jarg2;
42952   if (arg1) (arg1)->localPoint = *arg2;
42953 }
42954
42955
42956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42957   void * jresult ;
42958   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42959   Dali::Vector2 *result = 0 ;
42960
42961   arg1 = (Dali::TapGesture *)jarg1;
42962   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42963   jresult = (void *)result;
42964   return jresult;
42965 }
42966
42967
42968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42969   void * jresult ;
42970   Dali::AlphaFunction *result = 0 ;
42971
42972   {
42973     try {
42974       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42975     } catch (std::out_of_range& e) {
42976       {
42977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42978       };
42979     } catch (std::exception& e) {
42980       {
42981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42982       };
42983     } catch (Dali::DaliException e) {
42984       {
42985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42986       };
42987     } catch (...) {
42988       {
42989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42990       };
42991     }
42992   }
42993
42994   jresult = (void *)result;
42995   return jresult;
42996 }
42997
42998
42999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
43000   void * jresult ;
43001   Dali::AlphaFunction::BuiltinFunction arg1 ;
43002   Dali::AlphaFunction *result = 0 ;
43003
43004   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
43005   {
43006     try {
43007       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
43008     } catch (std::out_of_range& e) {
43009       {
43010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43011       };
43012     } catch (std::exception& e) {
43013       {
43014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43015       };
43016     } catch (Dali::DaliException e) {
43017       {
43018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43019       };
43020     } catch (...) {
43021       {
43022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43023       };
43024     }
43025   }
43026
43027   jresult = (void *)result;
43028   return jresult;
43029 }
43030
43031
43032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
43033   void * jresult ;
43034   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
43035   Dali::AlphaFunction *result = 0 ;
43036
43037   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
43038   {
43039     try {
43040       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
43041     } catch (std::out_of_range& e) {
43042       {
43043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43044       };
43045     } catch (std::exception& e) {
43046       {
43047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43048       };
43049     } catch (Dali::DaliException e) {
43050       {
43051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43052       };
43053     } catch (...) {
43054       {
43055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43056       };
43057     }
43058   }
43059
43060   jresult = (void *)result;
43061   return jresult;
43062 }
43063
43064
43065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
43066   void * jresult ;
43067   Dali::Vector2 *arg1 = 0 ;
43068   Dali::Vector2 *arg2 = 0 ;
43069   Dali::AlphaFunction *result = 0 ;
43070
43071   arg1 = (Dali::Vector2 *)jarg1;
43072   if (!arg1) {
43073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43074     return 0;
43075   }
43076   arg2 = (Dali::Vector2 *)jarg2;
43077   if (!arg2) {
43078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43079     return 0;
43080   }
43081   {
43082     try {
43083       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
43084     } catch (std::out_of_range& e) {
43085       {
43086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43087       };
43088     } catch (std::exception& e) {
43089       {
43090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43091       };
43092     } catch (Dali::DaliException e) {
43093       {
43094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43095       };
43096     } catch (...) {
43097       {
43098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43099       };
43100     }
43101   }
43102
43103   jresult = (void *)result;
43104   return jresult;
43105 }
43106
43107
43108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
43109   void * jresult ;
43110   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43111   Dali::Vector4 result;
43112
43113   arg1 = (Dali::AlphaFunction *)jarg1;
43114   {
43115     try {
43116       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
43117     } catch (std::out_of_range& e) {
43118       {
43119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43120       };
43121     } catch (std::exception& e) {
43122       {
43123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43124       };
43125     } catch (Dali::DaliException e) {
43126       {
43127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43128       };
43129     } catch (...) {
43130       {
43131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43132       };
43133     }
43134   }
43135
43136   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43137   return jresult;
43138 }
43139
43140
43141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
43142   void * jresult ;
43143   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43144   Dali::AlphaFunctionPrototype result;
43145
43146   arg1 = (Dali::AlphaFunction *)jarg1;
43147   {
43148     try {
43149       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
43150     } catch (std::out_of_range& e) {
43151       {
43152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43153       };
43154     } catch (std::exception& e) {
43155       {
43156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43157       };
43158     } catch (Dali::DaliException e) {
43159       {
43160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43161       };
43162     } catch (...) {
43163       {
43164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43165       };
43166     }
43167   }
43168
43169   jresult = (void *)result;
43170   return jresult;
43171 }
43172
43173
43174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43175   int jresult ;
43176   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43177   Dali::AlphaFunction::BuiltinFunction result;
43178
43179   arg1 = (Dali::AlphaFunction *)jarg1;
43180   {
43181     try {
43182       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43183     } catch (std::out_of_range& e) {
43184       {
43185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43186       };
43187     } catch (std::exception& e) {
43188       {
43189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43190       };
43191     } catch (Dali::DaliException e) {
43192       {
43193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43194       };
43195     } catch (...) {
43196       {
43197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43198       };
43199     }
43200   }
43201
43202   jresult = (int)result;
43203   return jresult;
43204 }
43205
43206
43207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43208   int jresult ;
43209   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43210   Dali::AlphaFunction::Mode result;
43211
43212   arg1 = (Dali::AlphaFunction *)jarg1;
43213   {
43214     try {
43215       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43216     } catch (std::out_of_range& e) {
43217       {
43218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43219       };
43220     } catch (std::exception& e) {
43221       {
43222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43223       };
43224     } catch (Dali::DaliException e) {
43225       {
43226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43227       };
43228     } catch (...) {
43229       {
43230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43231       };
43232     }
43233   }
43234
43235   jresult = (int)result;
43236   return jresult;
43237 }
43238
43239
43240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43241   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43242
43243   arg1 = (Dali::AlphaFunction *)jarg1;
43244   {
43245     try {
43246       delete arg1;
43247     } catch (std::out_of_range& e) {
43248       {
43249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43250       };
43251     } catch (std::exception& e) {
43252       {
43253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43254       };
43255     } catch (Dali::DaliException e) {
43256       {
43257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43258       };
43259     } catch (...) {
43260       {
43261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43262       };
43263     }
43264   }
43265
43266 }
43267
43268
43269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43270   void * jresult ;
43271   Dali::KeyFrames result;
43272
43273   {
43274     try {
43275       result = Dali::KeyFrames::New();
43276     } catch (std::out_of_range& e) {
43277       {
43278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43279       };
43280     } catch (std::exception& e) {
43281       {
43282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43283       };
43284     } catch (Dali::DaliException e) {
43285       {
43286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43287       };
43288     } catch (...) {
43289       {
43290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43291       };
43292     }
43293   }
43294
43295   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43296   return jresult;
43297 }
43298
43299
43300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43301   void * jresult ;
43302   Dali::BaseHandle arg1 ;
43303   Dali::BaseHandle *argp1 ;
43304   Dali::KeyFrames result;
43305
43306   argp1 = (Dali::BaseHandle *)jarg1;
43307   if (!argp1) {
43308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43309     return 0;
43310   }
43311   arg1 = *argp1;
43312   {
43313     try {
43314       result = Dali::KeyFrames::DownCast(arg1);
43315     } catch (std::out_of_range& e) {
43316       {
43317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43318       };
43319     } catch (std::exception& e) {
43320       {
43321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43322       };
43323     } catch (Dali::DaliException e) {
43324       {
43325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43326       };
43327     } catch (...) {
43328       {
43329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43330       };
43331     }
43332   }
43333
43334   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43335   return jresult;
43336 }
43337
43338
43339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43340   void * jresult ;
43341   Dali::KeyFrames *result = 0 ;
43342
43343   {
43344     try {
43345       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43346     } catch (std::out_of_range& e) {
43347       {
43348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43349       };
43350     } catch (std::exception& e) {
43351       {
43352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43353       };
43354     } catch (Dali::DaliException e) {
43355       {
43356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43357       };
43358     } catch (...) {
43359       {
43360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43361       };
43362     }
43363   }
43364
43365   jresult = (void *)result;
43366   return jresult;
43367 }
43368
43369
43370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43371   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43372
43373   arg1 = (Dali::KeyFrames *)jarg1;
43374   {
43375     try {
43376       delete arg1;
43377     } catch (std::out_of_range& e) {
43378       {
43379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43380       };
43381     } catch (std::exception& e) {
43382       {
43383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43384       };
43385     } catch (Dali::DaliException e) {
43386       {
43387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43388       };
43389     } catch (...) {
43390       {
43391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43392       };
43393     }
43394   }
43395
43396 }
43397
43398
43399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43400   void * jresult ;
43401   Dali::KeyFrames *arg1 = 0 ;
43402   Dali::KeyFrames *result = 0 ;
43403
43404   arg1 = (Dali::KeyFrames *)jarg1;
43405   if (!arg1) {
43406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43407     return 0;
43408   }
43409   {
43410     try {
43411       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43412     } catch (std::out_of_range& e) {
43413       {
43414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43415       };
43416     } catch (std::exception& e) {
43417       {
43418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43419       };
43420     } catch (Dali::DaliException e) {
43421       {
43422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43423       };
43424     } catch (...) {
43425       {
43426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43427       };
43428     }
43429   }
43430
43431   jresult = (void *)result;
43432   return jresult;
43433 }
43434
43435
43436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43437   void * jresult ;
43438   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43439   Dali::KeyFrames *arg2 = 0 ;
43440   Dali::KeyFrames *result = 0 ;
43441
43442   arg1 = (Dali::KeyFrames *)jarg1;
43443   arg2 = (Dali::KeyFrames *)jarg2;
43444   if (!arg2) {
43445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43446     return 0;
43447   }
43448   {
43449     try {
43450       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43451     } catch (std::out_of_range& e) {
43452       {
43453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43454       };
43455     } catch (std::exception& e) {
43456       {
43457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43458       };
43459     } catch (Dali::DaliException e) {
43460       {
43461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43462       };
43463     } catch (...) {
43464       {
43465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43466       };
43467     }
43468   }
43469
43470   jresult = (void *)result;
43471   return jresult;
43472 }
43473
43474
43475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43476   int jresult ;
43477   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43478   Dali::Property::Type result;
43479
43480   arg1 = (Dali::KeyFrames *)jarg1;
43481   {
43482     try {
43483       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43484     } catch (std::out_of_range& e) {
43485       {
43486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43487       };
43488     } catch (std::exception& e) {
43489       {
43490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43491       };
43492     } catch (Dali::DaliException e) {
43493       {
43494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43495       };
43496     } catch (...) {
43497       {
43498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43499       };
43500     }
43501   }
43502
43503   jresult = (int)result;
43504   return jresult;
43505 }
43506
43507
43508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43509   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43510   float arg2 ;
43511   Dali::Property::Value arg3 ;
43512   Dali::Property::Value *argp3 ;
43513
43514   arg1 = (Dali::KeyFrames *)jarg1;
43515   arg2 = (float)jarg2;
43516   argp3 = (Dali::Property::Value *)jarg3;
43517   if (!argp3) {
43518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43519     return ;
43520   }
43521   arg3 = *argp3;
43522   {
43523     try {
43524       (arg1)->Add(arg2,arg3);
43525     } catch (std::out_of_range& e) {
43526       {
43527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43528       };
43529     } catch (std::exception& e) {
43530       {
43531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43532       };
43533     } catch (Dali::DaliException e) {
43534       {
43535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43536       };
43537     } catch (...) {
43538       {
43539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43540       };
43541     }
43542   }
43543
43544 }
43545
43546
43547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43548   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43549   float arg2 ;
43550   Dali::Property::Value arg3 ;
43551   Dali::AlphaFunction arg4 ;
43552   Dali::Property::Value *argp3 ;
43553   Dali::AlphaFunction *argp4 ;
43554
43555   arg1 = (Dali::KeyFrames *)jarg1;
43556   arg2 = (float)jarg2;
43557   argp3 = (Dali::Property::Value *)jarg3;
43558   if (!argp3) {
43559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43560     return ;
43561   }
43562   arg3 = *argp3;
43563   argp4 = (Dali::AlphaFunction *)jarg4;
43564   if (!argp4) {
43565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43566     return ;
43567   }
43568   arg4 = *argp4;
43569   {
43570     try {
43571       (arg1)->Add(arg2,arg3,arg4);
43572     } catch (std::out_of_range& e) {
43573       {
43574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43575       };
43576     } catch (std::exception& e) {
43577       {
43578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43579       };
43580     } catch (Dali::DaliException e) {
43581       {
43582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43583       };
43584     } catch (...) {
43585       {
43586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43587       };
43588     }
43589   }
43590
43591 }
43592
43593
43594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43595   int jresult ;
43596   int result;
43597
43598   result = (int)Dali::Path::Property::POINTS;
43599   jresult = (int)result;
43600   return jresult;
43601 }
43602
43603
43604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43605   int jresult ;
43606   int result;
43607
43608   result = (int)Dali::Path::Property::CONTROL_POINTS;
43609   jresult = (int)result;
43610   return jresult;
43611 }
43612
43613
43614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43615   void * jresult ;
43616   Dali::Path::Property *result = 0 ;
43617
43618   {
43619     try {
43620       result = (Dali::Path::Property *)new Dali::Path::Property();
43621     } catch (std::out_of_range& e) {
43622       {
43623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43624       };
43625     } catch (std::exception& e) {
43626       {
43627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43628       };
43629     } catch (Dali::DaliException e) {
43630       {
43631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43632       };
43633     } catch (...) {
43634       {
43635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43636       };
43637     }
43638   }
43639
43640   jresult = (void *)result;
43641   return jresult;
43642 }
43643
43644
43645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43646   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43647
43648   arg1 = (Dali::Path::Property *)jarg1;
43649   {
43650     try {
43651       delete arg1;
43652     } catch (std::out_of_range& e) {
43653       {
43654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43655       };
43656     } catch (std::exception& e) {
43657       {
43658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43659       };
43660     } catch (Dali::DaliException e) {
43661       {
43662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43663       };
43664     } catch (...) {
43665       {
43666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43667       };
43668     }
43669   }
43670
43671 }
43672
43673
43674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43675   void * jresult ;
43676   Dali::Path result;
43677
43678   {
43679     try {
43680       result = Dali::Path::New();
43681     } catch (std::out_of_range& e) {
43682       {
43683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43684       };
43685     } catch (std::exception& e) {
43686       {
43687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43688       };
43689     } catch (Dali::DaliException e) {
43690       {
43691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43692       };
43693     } catch (...) {
43694       {
43695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43696       };
43697     }
43698   }
43699
43700   jresult = new Dali::Path((const Dali::Path &)result);
43701   return jresult;
43702 }
43703
43704
43705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43706   void * jresult ;
43707   Dali::BaseHandle arg1 ;
43708   Dali::BaseHandle *argp1 ;
43709   Dali::Path result;
43710
43711   argp1 = (Dali::BaseHandle *)jarg1;
43712   if (!argp1) {
43713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43714     return 0;
43715   }
43716   arg1 = *argp1;
43717   {
43718     try {
43719       result = Dali::Path::DownCast(arg1);
43720     } catch (std::out_of_range& e) {
43721       {
43722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43723       };
43724     } catch (std::exception& e) {
43725       {
43726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43727       };
43728     } catch (Dali::DaliException e) {
43729       {
43730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43731       };
43732     } catch (...) {
43733       {
43734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43735       };
43736     }
43737   }
43738
43739   jresult = new Dali::Path((const Dali::Path &)result);
43740   return jresult;
43741 }
43742
43743
43744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43745   void * jresult ;
43746   Dali::Path *result = 0 ;
43747
43748   {
43749     try {
43750       result = (Dali::Path *)new Dali::Path();
43751     } catch (std::out_of_range& e) {
43752       {
43753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43754       };
43755     } catch (std::exception& e) {
43756       {
43757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43758       };
43759     } catch (Dali::DaliException e) {
43760       {
43761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43762       };
43763     } catch (...) {
43764       {
43765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43766       };
43767     }
43768   }
43769
43770   jresult = (void *)result;
43771   return jresult;
43772 }
43773
43774
43775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43776   Dali::Path *arg1 = (Dali::Path *) 0 ;
43777
43778   arg1 = (Dali::Path *)jarg1;
43779   {
43780     try {
43781       delete arg1;
43782     } catch (std::out_of_range& e) {
43783       {
43784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43785       };
43786     } catch (std::exception& e) {
43787       {
43788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43789       };
43790     } catch (Dali::DaliException e) {
43791       {
43792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43793       };
43794     } catch (...) {
43795       {
43796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43797       };
43798     }
43799   }
43800
43801 }
43802
43803
43804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43805   void * jresult ;
43806   Dali::Path *arg1 = 0 ;
43807   Dali::Path *result = 0 ;
43808
43809   arg1 = (Dali::Path *)jarg1;
43810   if (!arg1) {
43811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43812     return 0;
43813   }
43814   {
43815     try {
43816       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43817     } catch (std::out_of_range& e) {
43818       {
43819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43820       };
43821     } catch (std::exception& e) {
43822       {
43823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43824       };
43825     } catch (Dali::DaliException e) {
43826       {
43827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43828       };
43829     } catch (...) {
43830       {
43831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43832       };
43833     }
43834   }
43835
43836   jresult = (void *)result;
43837   return jresult;
43838 }
43839
43840
43841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43842   void * jresult ;
43843   Dali::Path *arg1 = (Dali::Path *) 0 ;
43844   Dali::Path *arg2 = 0 ;
43845   Dali::Path *result = 0 ;
43846
43847   arg1 = (Dali::Path *)jarg1;
43848   arg2 = (Dali::Path *)jarg2;
43849   if (!arg2) {
43850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43851     return 0;
43852   }
43853   {
43854     try {
43855       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43856     } catch (std::out_of_range& e) {
43857       {
43858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43859       };
43860     } catch (std::exception& e) {
43861       {
43862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43863       };
43864     } catch (Dali::DaliException e) {
43865       {
43866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43867       };
43868     } catch (...) {
43869       {
43870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43871       };
43872     }
43873   }
43874
43875   jresult = (void *)result;
43876   return jresult;
43877 }
43878
43879
43880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43881   Dali::Path *arg1 = (Dali::Path *) 0 ;
43882   Dali::Vector3 *arg2 = 0 ;
43883
43884   arg1 = (Dali::Path *)jarg1;
43885   arg2 = (Dali::Vector3 *)jarg2;
43886   if (!arg2) {
43887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43888     return ;
43889   }
43890   {
43891     try {
43892       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43893     } catch (std::out_of_range& e) {
43894       {
43895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43896       };
43897     } catch (std::exception& e) {
43898       {
43899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43900       };
43901     } catch (Dali::DaliException e) {
43902       {
43903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43904       };
43905     } catch (...) {
43906       {
43907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43908       };
43909     }
43910   }
43911
43912 }
43913
43914
43915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43916   Dali::Path *arg1 = (Dali::Path *) 0 ;
43917   Dali::Vector3 *arg2 = 0 ;
43918
43919   arg1 = (Dali::Path *)jarg1;
43920   arg2 = (Dali::Vector3 *)jarg2;
43921   if (!arg2) {
43922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43923     return ;
43924   }
43925   {
43926     try {
43927       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43928     } catch (std::out_of_range& e) {
43929       {
43930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43931       };
43932     } catch (std::exception& e) {
43933       {
43934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43935       };
43936     } catch (Dali::DaliException e) {
43937       {
43938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43939       };
43940     } catch (...) {
43941       {
43942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43943       };
43944     }
43945   }
43946
43947 }
43948
43949
43950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43951   Dali::Path *arg1 = (Dali::Path *) 0 ;
43952   float arg2 ;
43953
43954   arg1 = (Dali::Path *)jarg1;
43955   arg2 = (float)jarg2;
43956   {
43957     try {
43958       (arg1)->GenerateControlPoints(arg2);
43959     } catch (std::out_of_range& e) {
43960       {
43961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43962       };
43963     } catch (std::exception& e) {
43964       {
43965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43966       };
43967     } catch (Dali::DaliException e) {
43968       {
43969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43970       };
43971     } catch (...) {
43972       {
43973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43974       };
43975     }
43976   }
43977
43978 }
43979
43980
43981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43982   Dali::Path *arg1 = (Dali::Path *) 0 ;
43983   float arg2 ;
43984   Dali::Vector3 *arg3 = 0 ;
43985   Dali::Vector3 *arg4 = 0 ;
43986
43987   arg1 = (Dali::Path *)jarg1;
43988   arg2 = (float)jarg2;
43989   arg3 = (Dali::Vector3 *)jarg3;
43990   if (!arg3) {
43991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43992     return ;
43993   }
43994   arg4 = (Dali::Vector3 *)jarg4;
43995   if (!arg4) {
43996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43997     return ;
43998   }
43999   {
44000     try {
44001       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
44002     } catch (std::out_of_range& e) {
44003       {
44004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44005       };
44006     } catch (std::exception& e) {
44007       {
44008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44009       };
44010     } catch (Dali::DaliException e) {
44011       {
44012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44013       };
44014     } catch (...) {
44015       {
44016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44017       };
44018     }
44019   }
44020
44021 }
44022
44023
44024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
44025   void * jresult ;
44026   Dali::Path *arg1 = (Dali::Path *) 0 ;
44027   size_t arg2 ;
44028   Dali::Vector3 *result = 0 ;
44029
44030   arg1 = (Dali::Path *)jarg1;
44031   arg2 = (size_t)jarg2;
44032   {
44033     try {
44034       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
44035     } catch (std::out_of_range& e) {
44036       {
44037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44038       };
44039     } catch (std::exception& e) {
44040       {
44041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44042       };
44043     } catch (Dali::DaliException e) {
44044       {
44045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44046       };
44047     } catch (...) {
44048       {
44049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44050       };
44051     }
44052   }
44053
44054   jresult = (void *)result;
44055   return jresult;
44056 }
44057
44058
44059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
44060   void * jresult ;
44061   Dali::Path *arg1 = (Dali::Path *) 0 ;
44062   size_t arg2 ;
44063   Dali::Vector3 *result = 0 ;
44064
44065   arg1 = (Dali::Path *)jarg1;
44066   arg2 = (size_t)jarg2;
44067   {
44068     try {
44069       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
44070     } catch (std::out_of_range& e) {
44071       {
44072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44073       };
44074     } catch (std::exception& e) {
44075       {
44076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44077       };
44078     } catch (Dali::DaliException e) {
44079       {
44080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44081       };
44082     } catch (...) {
44083       {
44084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44085       };
44086     }
44087   }
44088
44089   jresult = (void *)result;
44090   return jresult;
44091 }
44092
44093
44094 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
44095   unsigned long jresult ;
44096   Dali::Path *arg1 = (Dali::Path *) 0 ;
44097   size_t result;
44098
44099   arg1 = (Dali::Path *)jarg1;
44100   {
44101     try {
44102       result = ((Dali::Path const *)arg1)->GetPointCount();
44103     } catch (std::out_of_range& e) {
44104       {
44105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44106       };
44107     } catch (std::exception& e) {
44108       {
44109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44110       };
44111     } catch (Dali::DaliException e) {
44112       {
44113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44114       };
44115     } catch (...) {
44116       {
44117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44118       };
44119     }
44120   }
44121
44122   jresult = (unsigned long)result;
44123   return jresult;
44124 }
44125
44126
44127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
44128   void * jresult ;
44129   float arg1 ;
44130   Dali::TimePeriod *result = 0 ;
44131
44132   arg1 = (float)jarg1;
44133   {
44134     try {
44135       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
44136     } catch (std::out_of_range& e) {
44137       {
44138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44139       };
44140     } catch (std::exception& e) {
44141       {
44142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44143       };
44144     } catch (Dali::DaliException e) {
44145       {
44146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44147       };
44148     } catch (...) {
44149       {
44150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44151       };
44152     }
44153   }
44154
44155   jresult = (void *)result;
44156   return jresult;
44157 }
44158
44159
44160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
44161   void * jresult ;
44162   float arg1 ;
44163   float arg2 ;
44164   Dali::TimePeriod *result = 0 ;
44165
44166   arg1 = (float)jarg1;
44167   arg2 = (float)jarg2;
44168   {
44169     try {
44170       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44171     } catch (std::out_of_range& e) {
44172       {
44173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44174       };
44175     } catch (std::exception& e) {
44176       {
44177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44178       };
44179     } catch (Dali::DaliException e) {
44180       {
44181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44182       };
44183     } catch (...) {
44184       {
44185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44186       };
44187     }
44188   }
44189
44190   jresult = (void *)result;
44191   return jresult;
44192 }
44193
44194
44195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44196   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44197
44198   arg1 = (Dali::TimePeriod *)jarg1;
44199   {
44200     try {
44201       delete arg1;
44202     } catch (std::out_of_range& e) {
44203       {
44204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44205       };
44206     } catch (std::exception& e) {
44207       {
44208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44209       };
44210     } catch (Dali::DaliException e) {
44211       {
44212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44213       };
44214     } catch (...) {
44215       {
44216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44217       };
44218     }
44219   }
44220
44221 }
44222
44223
44224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44225   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44226   float arg2 ;
44227
44228   arg1 = (Dali::TimePeriod *)jarg1;
44229   arg2 = (float)jarg2;
44230   if (arg1) (arg1)->delaySeconds = arg2;
44231 }
44232
44233
44234 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44235   float jresult ;
44236   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44237   float result;
44238
44239   arg1 = (Dali::TimePeriod *)jarg1;
44240   result = (float) ((arg1)->delaySeconds);
44241   jresult = result;
44242   return jresult;
44243 }
44244
44245
44246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44247   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44248   float arg2 ;
44249
44250   arg1 = (Dali::TimePeriod *)jarg1;
44251   arg2 = (float)jarg2;
44252   if (arg1) (arg1)->durationSeconds = arg2;
44253 }
44254
44255
44256 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44257   float jresult ;
44258   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44259   float result;
44260
44261   arg1 = (Dali::TimePeriod *)jarg1;
44262   result = (float) ((arg1)->durationSeconds);
44263   jresult = result;
44264   return jresult;
44265 }
44266
44267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44268   int jresult ;
44269   int result;
44270
44271   result = (int)Dali::LinearConstrainer::Property::VALUE;
44272   jresult = (int)result;
44273   return jresult;
44274 }
44275
44276
44277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44278   int jresult ;
44279   int result;
44280
44281   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44282   jresult = (int)result;
44283   return jresult;
44284 }
44285
44286
44287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44288   void * jresult ;
44289   Dali::LinearConstrainer::Property *result = 0 ;
44290
44291   {
44292     try {
44293       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44294     } catch (std::out_of_range& e) {
44295       {
44296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44297       };
44298     } catch (std::exception& e) {
44299       {
44300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44301       };
44302     } catch (Dali::DaliException e) {
44303       {
44304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44305       };
44306     } catch (...) {
44307       {
44308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44309       };
44310     }
44311   }
44312
44313   jresult = (void *)result;
44314   return jresult;
44315 }
44316
44317
44318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44319   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44320
44321   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44322   {
44323     try {
44324       delete arg1;
44325     } catch (std::out_of_range& e) {
44326       {
44327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44328       };
44329     } catch (std::exception& e) {
44330       {
44331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44332       };
44333     } catch (Dali::DaliException e) {
44334       {
44335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44336       };
44337     } catch (...) {
44338       {
44339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44340       };
44341     }
44342   }
44343
44344 }
44345
44346
44347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44348   void * jresult ;
44349   Dali::LinearConstrainer result;
44350
44351   {
44352     try {
44353       result = Dali::LinearConstrainer::New();
44354     } catch (std::out_of_range& e) {
44355       {
44356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44357       };
44358     } catch (std::exception& e) {
44359       {
44360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44361       };
44362     } catch (Dali::DaliException e) {
44363       {
44364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44365       };
44366     } catch (...) {
44367       {
44368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44369       };
44370     }
44371   }
44372
44373   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44374   return jresult;
44375 }
44376
44377
44378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44379   void * jresult ;
44380   Dali::BaseHandle arg1 ;
44381   Dali::BaseHandle *argp1 ;
44382   Dali::LinearConstrainer result;
44383
44384   argp1 = (Dali::BaseHandle *)jarg1;
44385   if (!argp1) {
44386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44387     return 0;
44388   }
44389   arg1 = *argp1;
44390   {
44391     try {
44392       result = Dali::LinearConstrainer::DownCast(arg1);
44393     } catch (std::out_of_range& e) {
44394       {
44395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44396       };
44397     } catch (std::exception& e) {
44398       {
44399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44400       };
44401     } catch (Dali::DaliException e) {
44402       {
44403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44404       };
44405     } catch (...) {
44406       {
44407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44408       };
44409     }
44410   }
44411
44412   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44413   return jresult;
44414 }
44415
44416
44417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44418   void * jresult ;
44419   Dali::LinearConstrainer *result = 0 ;
44420
44421   {
44422     try {
44423       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44424     } catch (std::out_of_range& e) {
44425       {
44426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44427       };
44428     } catch (std::exception& e) {
44429       {
44430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44431       };
44432     } catch (Dali::DaliException e) {
44433       {
44434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44435       };
44436     } catch (...) {
44437       {
44438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44439       };
44440     }
44441   }
44442
44443   jresult = (void *)result;
44444   return jresult;
44445 }
44446
44447
44448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44449   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44450
44451   arg1 = (Dali::LinearConstrainer *)jarg1;
44452   {
44453     try {
44454       delete arg1;
44455     } catch (std::out_of_range& e) {
44456       {
44457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44458       };
44459     } catch (std::exception& e) {
44460       {
44461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44462       };
44463     } catch (Dali::DaliException e) {
44464       {
44465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44466       };
44467     } catch (...) {
44468       {
44469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44470       };
44471     }
44472   }
44473
44474 }
44475
44476
44477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44478   void * jresult ;
44479   Dali::LinearConstrainer *arg1 = 0 ;
44480   Dali::LinearConstrainer *result = 0 ;
44481
44482   arg1 = (Dali::LinearConstrainer *)jarg1;
44483   if (!arg1) {
44484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44485     return 0;
44486   }
44487   {
44488     try {
44489       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44490     } catch (std::out_of_range& e) {
44491       {
44492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44493       };
44494     } catch (std::exception& e) {
44495       {
44496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44497       };
44498     } catch (Dali::DaliException e) {
44499       {
44500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44501       };
44502     } catch (...) {
44503       {
44504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44505       };
44506     }
44507   }
44508
44509   jresult = (void *)result;
44510   return jresult;
44511 }
44512
44513
44514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44515   void * jresult ;
44516   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44517   Dali::LinearConstrainer *arg2 = 0 ;
44518   Dali::LinearConstrainer *result = 0 ;
44519
44520   arg1 = (Dali::LinearConstrainer *)jarg1;
44521   arg2 = (Dali::LinearConstrainer *)jarg2;
44522   if (!arg2) {
44523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44524     return 0;
44525   }
44526   {
44527     try {
44528       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44529     } catch (std::out_of_range& e) {
44530       {
44531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44532       };
44533     } catch (std::exception& e) {
44534       {
44535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44536       };
44537     } catch (Dali::DaliException e) {
44538       {
44539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44540       };
44541     } catch (...) {
44542       {
44543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44544       };
44545     }
44546   }
44547
44548   jresult = (void *)result;
44549   return jresult;
44550 }
44551
44552
44553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44554   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44555   SwigValueWrapper< Dali::Property > arg2 ;
44556   SwigValueWrapper< Dali::Property > arg3 ;
44557   Dali::Vector2 *arg4 = 0 ;
44558   Dali::Vector2 *arg5 = 0 ;
44559   Dali::Property *argp2 ;
44560   Dali::Property *argp3 ;
44561
44562   arg1 = (Dali::LinearConstrainer *)jarg1;
44563   argp2 = (Dali::Property *)jarg2;
44564   if (!argp2) {
44565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44566     return ;
44567   }
44568   arg2 = *argp2;
44569   argp3 = (Dali::Property *)jarg3;
44570   if (!argp3) {
44571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44572     return ;
44573   }
44574   arg3 = *argp3;
44575   arg4 = (Dali::Vector2 *)jarg4;
44576   if (!arg4) {
44577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44578     return ;
44579   }
44580   arg5 = (Dali::Vector2 *)jarg5;
44581   if (!arg5) {
44582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44583     return ;
44584   }
44585   {
44586     try {
44587       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44588     } catch (std::out_of_range& e) {
44589       {
44590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44591       };
44592     } catch (std::exception& e) {
44593       {
44594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44595       };
44596     } catch (Dali::DaliException e) {
44597       {
44598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44599       };
44600     } catch (...) {
44601       {
44602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44603       };
44604     }
44605   }
44606
44607 }
44608
44609
44610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44611   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44612   SwigValueWrapper< Dali::Property > arg2 ;
44613   SwigValueWrapper< Dali::Property > arg3 ;
44614   Dali::Vector2 *arg4 = 0 ;
44615   Dali::Property *argp2 ;
44616   Dali::Property *argp3 ;
44617
44618   arg1 = (Dali::LinearConstrainer *)jarg1;
44619   argp2 = (Dali::Property *)jarg2;
44620   if (!argp2) {
44621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44622     return ;
44623   }
44624   arg2 = *argp2;
44625   argp3 = (Dali::Property *)jarg3;
44626   if (!argp3) {
44627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44628     return ;
44629   }
44630   arg3 = *argp3;
44631   arg4 = (Dali::Vector2 *)jarg4;
44632   if (!arg4) {
44633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44634     return ;
44635   }
44636   {
44637     try {
44638       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44639     } catch (std::out_of_range& e) {
44640       {
44641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44642       };
44643     } catch (std::exception& e) {
44644       {
44645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44646       };
44647     } catch (Dali::DaliException e) {
44648       {
44649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44650       };
44651     } catch (...) {
44652       {
44653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44654       };
44655     }
44656   }
44657
44658 }
44659
44660
44661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44662   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44663   Dali::Handle *arg2 = 0 ;
44664
44665   arg1 = (Dali::LinearConstrainer *)jarg1;
44666   arg2 = (Dali::Handle *)jarg2;
44667   if (!arg2) {
44668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44669     return ;
44670   }
44671   {
44672     try {
44673       (arg1)->Remove(*arg2);
44674     } catch (std::out_of_range& e) {
44675       {
44676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44677       };
44678     } catch (std::exception& e) {
44679       {
44680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44681       };
44682     } catch (Dali::DaliException e) {
44683       {
44684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44685       };
44686     } catch (...) {
44687       {
44688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44689       };
44690     }
44691   }
44692
44693 }
44694
44695
44696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44697   int jresult ;
44698   int result;
44699
44700   result = (int)Dali::PathConstrainer::Property::FORWARD;
44701   jresult = (int)result;
44702   return jresult;
44703 }
44704
44705
44706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44707   int jresult ;
44708   int result;
44709
44710   result = (int)Dali::PathConstrainer::Property::POINTS;
44711   jresult = (int)result;
44712   return jresult;
44713 }
44714
44715
44716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44717   int jresult ;
44718   int result;
44719
44720   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44721   jresult = (int)result;
44722   return jresult;
44723 }
44724
44725
44726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44727   void * jresult ;
44728   Dali::PathConstrainer::Property *result = 0 ;
44729
44730   {
44731     try {
44732       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44733     } catch (std::out_of_range& e) {
44734       {
44735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44736       };
44737     } catch (std::exception& e) {
44738       {
44739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44740       };
44741     } catch (Dali::DaliException e) {
44742       {
44743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44744       };
44745     } catch (...) {
44746       {
44747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44748       };
44749     }
44750   }
44751
44752   jresult = (void *)result;
44753   return jresult;
44754 }
44755
44756
44757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44758   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44759
44760   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44761   {
44762     try {
44763       delete arg1;
44764     } catch (std::out_of_range& e) {
44765       {
44766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44767       };
44768     } catch (std::exception& e) {
44769       {
44770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44771       };
44772     } catch (Dali::DaliException e) {
44773       {
44774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44775       };
44776     } catch (...) {
44777       {
44778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44779       };
44780     }
44781   }
44782
44783 }
44784
44785
44786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44787   void * jresult ;
44788   Dali::PathConstrainer result;
44789
44790   {
44791     try {
44792       result = Dali::PathConstrainer::New();
44793     } catch (std::out_of_range& e) {
44794       {
44795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44796       };
44797     } catch (std::exception& e) {
44798       {
44799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44800       };
44801     } catch (Dali::DaliException e) {
44802       {
44803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44804       };
44805     } catch (...) {
44806       {
44807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44808       };
44809     }
44810   }
44811
44812   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44813   return jresult;
44814 }
44815
44816
44817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44818   void * jresult ;
44819   Dali::BaseHandle arg1 ;
44820   Dali::BaseHandle *argp1 ;
44821   Dali::PathConstrainer result;
44822
44823   argp1 = (Dali::BaseHandle *)jarg1;
44824   if (!argp1) {
44825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44826     return 0;
44827   }
44828   arg1 = *argp1;
44829   {
44830     try {
44831       result = Dali::PathConstrainer::DownCast(arg1);
44832     } catch (std::out_of_range& e) {
44833       {
44834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44835       };
44836     } catch (std::exception& e) {
44837       {
44838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44839       };
44840     } catch (Dali::DaliException e) {
44841       {
44842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44843       };
44844     } catch (...) {
44845       {
44846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44847       };
44848     }
44849   }
44850
44851   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44852   return jresult;
44853 }
44854
44855
44856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44857   void * jresult ;
44858   Dali::PathConstrainer *result = 0 ;
44859
44860   {
44861     try {
44862       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44863     } catch (std::out_of_range& e) {
44864       {
44865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44866       };
44867     } catch (std::exception& e) {
44868       {
44869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44870       };
44871     } catch (Dali::DaliException e) {
44872       {
44873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44874       };
44875     } catch (...) {
44876       {
44877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44878       };
44879     }
44880   }
44881
44882   jresult = (void *)result;
44883   return jresult;
44884 }
44885
44886
44887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44888   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44889
44890   arg1 = (Dali::PathConstrainer *)jarg1;
44891   {
44892     try {
44893       delete arg1;
44894     } catch (std::out_of_range& e) {
44895       {
44896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44897       };
44898     } catch (std::exception& e) {
44899       {
44900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44901       };
44902     } catch (Dali::DaliException e) {
44903       {
44904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44905       };
44906     } catch (...) {
44907       {
44908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44909       };
44910     }
44911   }
44912
44913 }
44914
44915
44916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44917   void * jresult ;
44918   Dali::PathConstrainer *arg1 = 0 ;
44919   Dali::PathConstrainer *result = 0 ;
44920
44921   arg1 = (Dali::PathConstrainer *)jarg1;
44922   if (!arg1) {
44923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44924     return 0;
44925   }
44926   {
44927     try {
44928       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44929     } catch (std::out_of_range& e) {
44930       {
44931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44932       };
44933     } catch (std::exception& e) {
44934       {
44935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44936       };
44937     } catch (Dali::DaliException e) {
44938       {
44939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44940       };
44941     } catch (...) {
44942       {
44943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44944       };
44945     }
44946   }
44947
44948   jresult = (void *)result;
44949   return jresult;
44950 }
44951
44952
44953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44954   void * jresult ;
44955   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44956   Dali::PathConstrainer *arg2 = 0 ;
44957   Dali::PathConstrainer *result = 0 ;
44958
44959   arg1 = (Dali::PathConstrainer *)jarg1;
44960   arg2 = (Dali::PathConstrainer *)jarg2;
44961   if (!arg2) {
44962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44963     return 0;
44964   }
44965   {
44966     try {
44967       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44968     } catch (std::out_of_range& e) {
44969       {
44970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44971       };
44972     } catch (std::exception& e) {
44973       {
44974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44975       };
44976     } catch (Dali::DaliException e) {
44977       {
44978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44979       };
44980     } catch (...) {
44981       {
44982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44983       };
44984     }
44985   }
44986
44987   jresult = (void *)result;
44988   return jresult;
44989 }
44990
44991
44992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44993   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44994   SwigValueWrapper< Dali::Property > arg2 ;
44995   SwigValueWrapper< Dali::Property > arg3 ;
44996   Dali::Vector2 *arg4 = 0 ;
44997   Dali::Vector2 *arg5 = 0 ;
44998   Dali::Property *argp2 ;
44999   Dali::Property *argp3 ;
45000
45001   arg1 = (Dali::PathConstrainer *)jarg1;
45002   argp2 = (Dali::Property *)jarg2;
45003   if (!argp2) {
45004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
45005     return ;
45006   }
45007   arg2 = *argp2;
45008   argp3 = (Dali::Property *)jarg3;
45009   if (!argp3) {
45010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
45011     return ;
45012   }
45013   arg3 = *argp3;
45014   arg4 = (Dali::Vector2 *)jarg4;
45015   if (!arg4) {
45016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45017     return ;
45018   }
45019   arg5 = (Dali::Vector2 *)jarg5;
45020   if (!arg5) {
45021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45022     return ;
45023   }
45024   {
45025     try {
45026       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
45027     } catch (std::out_of_range& e) {
45028       {
45029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45030       };
45031     } catch (std::exception& e) {
45032       {
45033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45034       };
45035     } catch (Dali::DaliException e) {
45036       {
45037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45038       };
45039     } catch (...) {
45040       {
45041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45042       };
45043     }
45044   }
45045
45046 }
45047
45048
45049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
45050   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
45051   SwigValueWrapper< Dali::Property > arg2 ;
45052   SwigValueWrapper< Dali::Property > arg3 ;
45053   Dali::Vector2 *arg4 = 0 ;
45054   Dali::Property *argp2 ;
45055   Dali::Property *argp3 ;
45056
45057   arg1 = (Dali::PathConstrainer *)jarg1;
45058   argp2 = (Dali::Property *)jarg2;
45059   if (!argp2) {
45060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
45061     return ;
45062   }
45063   arg2 = *argp2;
45064   argp3 = (Dali::Property *)jarg3;
45065   if (!argp3) {
45066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
45067     return ;
45068   }
45069   arg3 = *argp3;
45070   arg4 = (Dali::Vector2 *)jarg4;
45071   if (!arg4) {
45072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45073     return ;
45074   }
45075   {
45076     try {
45077       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
45078     } catch (std::out_of_range& e) {
45079       {
45080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45081       };
45082     } catch (std::exception& e) {
45083       {
45084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45085       };
45086     } catch (Dali::DaliException e) {
45087       {
45088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45089       };
45090     } catch (...) {
45091       {
45092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45093       };
45094     }
45095   }
45096
45097 }
45098
45099
45100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
45101   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
45102   Dali::Handle *arg2 = 0 ;
45103
45104   arg1 = (Dali::PathConstrainer *)jarg1;
45105   arg2 = (Dali::Handle *)jarg2;
45106   if (!arg2) {
45107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
45108     return ;
45109   }
45110   {
45111     try {
45112       (arg1)->Remove(*arg2);
45113     } catch (std::out_of_range& e) {
45114       {
45115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45116       };
45117     } catch (std::exception& e) {
45118       {
45119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45120       };
45121     } catch (Dali::DaliException e) {
45122       {
45123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45124       };
45125     } catch (...) {
45126       {
45127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45128       };
45129     }
45130   }
45131
45132 }
45133
45134
45135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
45136   int jresult ;
45137   Dali::FittingMode::Type result;
45138
45139   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
45140   jresult = (int)result;
45141   return jresult;
45142 }
45143
45144
45145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
45146   int jresult ;
45147   Dali::SamplingMode::Type result;
45148
45149   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
45150   jresult = (int)result;
45151   return jresult;
45152 }
45153
45154
45155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
45156   void * jresult ;
45157   Dali::BufferImage *result = 0 ;
45158
45159   {
45160     try {
45161       result = (Dali::BufferImage *)new Dali::BufferImage();
45162     } catch (std::out_of_range& e) {
45163       {
45164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45165       };
45166     } catch (std::exception& e) {
45167       {
45168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45169       };
45170     } catch (Dali::DaliException e) {
45171       {
45172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45173       };
45174     } catch (...) {
45175       {
45176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45177       };
45178     }
45179   }
45180
45181   jresult = (void *)result;
45182   return jresult;
45183 }
45184
45185
45186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45187   void * jresult ;
45188   unsigned int arg1 ;
45189   unsigned int arg2 ;
45190   Dali::Pixel::Format arg3 ;
45191   Dali::BufferImage result;
45192
45193   arg1 = (unsigned int)jarg1;
45194   arg2 = (unsigned int)jarg2;
45195   arg3 = (Dali::Pixel::Format)jarg3;
45196   {
45197     try {
45198       result = Dali::BufferImage::New(arg1,arg2,arg3);
45199     } catch (std::out_of_range& e) {
45200       {
45201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45202       };
45203     } catch (std::exception& e) {
45204       {
45205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45206       };
45207     } catch (Dali::DaliException e) {
45208       {
45209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45210       };
45211     } catch (...) {
45212       {
45213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45214       };
45215     }
45216   }
45217
45218   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45219   return jresult;
45220 }
45221
45222
45223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45224   void * jresult ;
45225   unsigned int arg1 ;
45226   unsigned int arg2 ;
45227   Dali::BufferImage result;
45228
45229   arg1 = (unsigned int)jarg1;
45230   arg2 = (unsigned int)jarg2;
45231   {
45232     try {
45233       result = Dali::BufferImage::New(arg1,arg2);
45234     } catch (std::out_of_range& e) {
45235       {
45236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45237       };
45238     } catch (std::exception& e) {
45239       {
45240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45241       };
45242     } catch (Dali::DaliException e) {
45243       {
45244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45245       };
45246     } catch (...) {
45247       {
45248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45249       };
45250     }
45251   }
45252
45253   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45254   return jresult;
45255 }
45256
45257
45258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45259   void * jresult ;
45260   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45261   unsigned int arg2 ;
45262   unsigned int arg3 ;
45263   Dali::Pixel::Format arg4 ;
45264   unsigned int arg5 ;
45265   Dali::BufferImage result;
45266
45267   arg1 = jarg1;
45268   arg2 = (unsigned int)jarg2;
45269   arg3 = (unsigned int)jarg3;
45270   arg4 = (Dali::Pixel::Format)jarg4;
45271   arg5 = (unsigned int)jarg5;
45272   {
45273     try {
45274       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45275     } catch (std::out_of_range& e) {
45276       {
45277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45278       };
45279     } catch (std::exception& e) {
45280       {
45281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45282       };
45283     } catch (Dali::DaliException e) {
45284       {
45285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45286       };
45287     } catch (...) {
45288       {
45289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45290       };
45291     }
45292   }
45293
45294   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45295
45296
45297   return jresult;
45298 }
45299
45300
45301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45302   void * jresult ;
45303   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45304   unsigned int arg2 ;
45305   unsigned int arg3 ;
45306   Dali::Pixel::Format arg4 ;
45307   Dali::BufferImage result;
45308
45309   arg1 = jarg1;
45310   arg2 = (unsigned int)jarg2;
45311   arg3 = (unsigned int)jarg3;
45312   arg4 = (Dali::Pixel::Format)jarg4;
45313   {
45314     try {
45315       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45316     } catch (std::out_of_range& e) {
45317       {
45318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45319       };
45320     } catch (std::exception& e) {
45321       {
45322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45323       };
45324     } catch (Dali::DaliException e) {
45325       {
45326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45327       };
45328     } catch (...) {
45329       {
45330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45331       };
45332     }
45333   }
45334
45335   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45336
45337
45338   return jresult;
45339 }
45340
45341
45342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45343   void * jresult ;
45344   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45345   unsigned int arg2 ;
45346   unsigned int arg3 ;
45347   Dali::BufferImage result;
45348
45349   arg1 = jarg1;
45350   arg2 = (unsigned int)jarg2;
45351   arg3 = (unsigned int)jarg3;
45352   {
45353     try {
45354       result = Dali::BufferImage::New(arg1,arg2,arg3);
45355     } catch (std::out_of_range& e) {
45356       {
45357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45358       };
45359     } catch (std::exception& e) {
45360       {
45361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45362       };
45363     } catch (Dali::DaliException e) {
45364       {
45365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45366       };
45367     } catch (...) {
45368       {
45369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45370       };
45371     }
45372   }
45373
45374   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45375
45376
45377   return jresult;
45378 }
45379
45380
45381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45382   void * jresult ;
45383   Dali::BaseHandle arg1 ;
45384   Dali::BaseHandle *argp1 ;
45385   Dali::BufferImage result;
45386
45387   argp1 = (Dali::BaseHandle *)jarg1;
45388   if (!argp1) {
45389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45390     return 0;
45391   }
45392   arg1 = *argp1;
45393   {
45394     try {
45395       result = Dali::BufferImage::DownCast(arg1);
45396     } catch (std::out_of_range& e) {
45397       {
45398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45399       };
45400     } catch (std::exception& e) {
45401       {
45402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45403       };
45404     } catch (Dali::DaliException e) {
45405       {
45406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45407       };
45408     } catch (...) {
45409       {
45410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45411       };
45412     }
45413   }
45414
45415   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45416   return jresult;
45417 }
45418
45419
45420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45421   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45422
45423   arg1 = (Dali::BufferImage *)jarg1;
45424   {
45425     try {
45426       delete arg1;
45427     } catch (std::out_of_range& e) {
45428       {
45429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45430       };
45431     } catch (std::exception& e) {
45432       {
45433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45434       };
45435     } catch (Dali::DaliException e) {
45436       {
45437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45438       };
45439     } catch (...) {
45440       {
45441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45442       };
45443     }
45444   }
45445
45446 }
45447
45448
45449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45450   void * jresult ;
45451   Dali::BufferImage *arg1 = 0 ;
45452   Dali::BufferImage *result = 0 ;
45453
45454   arg1 = (Dali::BufferImage *)jarg1;
45455   if (!arg1) {
45456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45457     return 0;
45458   }
45459   {
45460     try {
45461       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45462     } catch (std::out_of_range& e) {
45463       {
45464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45465       };
45466     } catch (std::exception& e) {
45467       {
45468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45469       };
45470     } catch (Dali::DaliException e) {
45471       {
45472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45473       };
45474     } catch (...) {
45475       {
45476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45477       };
45478     }
45479   }
45480
45481   jresult = (void *)result;
45482   return jresult;
45483 }
45484
45485
45486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45487   void * jresult ;
45488   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45489   Dali::BufferImage *arg2 = 0 ;
45490   Dali::BufferImage *result = 0 ;
45491
45492   arg1 = (Dali::BufferImage *)jarg1;
45493   arg2 = (Dali::BufferImage *)jarg2;
45494   if (!arg2) {
45495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45496     return 0;
45497   }
45498   {
45499     try {
45500       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45501     } catch (std::out_of_range& e) {
45502       {
45503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45504       };
45505     } catch (std::exception& e) {
45506       {
45507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45508       };
45509     } catch (Dali::DaliException e) {
45510       {
45511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45512       };
45513     } catch (...) {
45514       {
45515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45516       };
45517     }
45518   }
45519
45520   jresult = (void *)result;
45521   return jresult;
45522 }
45523
45524
45525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45526   void * jresult ;
45527   Dali::BufferImage result;
45528
45529   {
45530     try {
45531       result = Dali::BufferImage::WHITE();
45532     } catch (std::out_of_range& e) {
45533       {
45534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45535       };
45536     } catch (std::exception& e) {
45537       {
45538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45539       };
45540     } catch (Dali::DaliException e) {
45541       {
45542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45543       };
45544     } catch (...) {
45545       {
45546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45547       };
45548     }
45549   }
45550
45551   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45552   return jresult;
45553 }
45554
45555
45556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45557   void * jresult ;
45558   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45559   Dali::PixelBuffer *result = 0 ;
45560
45561   arg1 = (Dali::BufferImage *)jarg1;
45562   {
45563     try {
45564       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45565     } catch (std::out_of_range& e) {
45566       {
45567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45568       };
45569     } catch (std::exception& e) {
45570       {
45571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45572       };
45573     } catch (Dali::DaliException e) {
45574       {
45575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45576       };
45577     } catch (...) {
45578       {
45579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45580       };
45581     }
45582   }
45583
45584   jresult = (void *)result;
45585   return jresult;
45586 }
45587
45588
45589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45590   unsigned int jresult ;
45591   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45592   unsigned int result;
45593
45594   arg1 = (Dali::BufferImage *)jarg1;
45595   {
45596     try {
45597       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45598     } catch (std::out_of_range& e) {
45599       {
45600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45601       };
45602     } catch (std::exception& e) {
45603       {
45604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45605       };
45606     } catch (Dali::DaliException e) {
45607       {
45608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45609       };
45610     } catch (...) {
45611       {
45612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45613       };
45614     }
45615   }
45616
45617   jresult = result;
45618   return jresult;
45619 }
45620
45621
45622 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45623   unsigned int jresult ;
45624   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45625   unsigned int result;
45626
45627   arg1 = (Dali::BufferImage *)jarg1;
45628   {
45629     try {
45630       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45631     } catch (std::out_of_range& e) {
45632       {
45633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45634       };
45635     } catch (std::exception& e) {
45636       {
45637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45638       };
45639     } catch (Dali::DaliException e) {
45640       {
45641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45642       };
45643     } catch (...) {
45644       {
45645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45646       };
45647     }
45648   }
45649
45650   jresult = result;
45651   return jresult;
45652 }
45653
45654
45655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45656   int jresult ;
45657   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45658   Dali::Pixel::Format result;
45659
45660   arg1 = (Dali::BufferImage *)jarg1;
45661   {
45662     try {
45663       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45664     } catch (std::out_of_range& e) {
45665       {
45666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45667       };
45668     } catch (std::exception& e) {
45669       {
45670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45671       };
45672     } catch (Dali::DaliException e) {
45673       {
45674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45675       };
45676     } catch (...) {
45677       {
45678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45679       };
45680     }
45681   }
45682
45683   jresult = (int)result;
45684   return jresult;
45685 }
45686
45687
45688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45689   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45690
45691   arg1 = (Dali::BufferImage *)jarg1;
45692   {
45693     try {
45694       (arg1)->Update();
45695     } catch (std::out_of_range& e) {
45696       {
45697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45698       };
45699     } catch (std::exception& e) {
45700       {
45701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45702       };
45703     } catch (Dali::DaliException e) {
45704       {
45705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45706       };
45707     } catch (...) {
45708       {
45709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45710       };
45711     }
45712   }
45713
45714 }
45715
45716
45717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45718   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45719   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45720   Dali::RectArea *argp2 ;
45721
45722   arg1 = (Dali::BufferImage *)jarg1;
45723   argp2 = (Dali::RectArea *)jarg2;
45724   if (!argp2) {
45725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45726     return ;
45727   }
45728   arg2 = *argp2;
45729   {
45730     try {
45731       (arg1)->Update(arg2);
45732     } catch (std::out_of_range& e) {
45733       {
45734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45735       };
45736     } catch (std::exception& e) {
45737       {
45738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45739       };
45740     } catch (Dali::DaliException e) {
45741       {
45742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45743       };
45744     } catch (...) {
45745       {
45746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45747       };
45748     }
45749   }
45750
45751 }
45752
45753
45754 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45755   unsigned int jresult ;
45756   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45757   bool result;
45758
45759   arg1 = (Dali::BufferImage *)jarg1;
45760   {
45761     try {
45762       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45763     } catch (std::out_of_range& e) {
45764       {
45765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45766       };
45767     } catch (std::exception& e) {
45768       {
45769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45770       };
45771     } catch (Dali::DaliException e) {
45772       {
45773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45774       };
45775     } catch (...) {
45776       {
45777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45778       };
45779     }
45780   }
45781
45782   jresult = result;
45783   return jresult;
45784 }
45785
45786
45787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45788   void * jresult ;
45789   Dali::EncodedBufferImage *result = 0 ;
45790
45791   {
45792     try {
45793       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45794     } catch (std::out_of_range& e) {
45795       {
45796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45797       };
45798     } catch (std::exception& e) {
45799       {
45800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45801       };
45802     } catch (Dali::DaliException e) {
45803       {
45804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45805       };
45806     } catch (...) {
45807       {
45808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45809       };
45810     }
45811   }
45812
45813   jresult = (void *)result;
45814   return jresult;
45815 }
45816
45817
45818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45819   void * jresult ;
45820   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45821   std::size_t arg2 ;
45822   Dali::EncodedBufferImage result;
45823
45824   arg1 = (uint8_t *)jarg1;
45825   arg2 = (std::size_t)jarg2;
45826   {
45827     try {
45828       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45829     } catch (std::out_of_range& e) {
45830       {
45831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45832       };
45833     } catch (std::exception& e) {
45834       {
45835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45836       };
45837     } catch (Dali::DaliException e) {
45838       {
45839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45840       };
45841     } catch (...) {
45842       {
45843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45844       };
45845     }
45846   }
45847
45848   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45849   return jresult;
45850 }
45851
45852
45853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45854   void * jresult ;
45855   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45856   std::size_t arg2 ;
45857   Dali::ImageDimensions arg3 ;
45858   Dali::FittingMode::Type arg4 ;
45859   Dali::SamplingMode::Type arg5 ;
45860   bool arg6 ;
45861   Dali::ImageDimensions *argp3 ;
45862   Dali::EncodedBufferImage result;
45863
45864   arg1 = (uint8_t *)jarg1;
45865   arg2 = (std::size_t)jarg2;
45866   argp3 = (Dali::ImageDimensions *)jarg3;
45867   if (!argp3) {
45868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45869     return 0;
45870   }
45871   arg3 = *argp3;
45872   arg4 = (Dali::FittingMode::Type)jarg4;
45873   arg5 = (Dali::SamplingMode::Type)jarg5;
45874   arg6 = jarg6 ? true : false;
45875   {
45876     try {
45877       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45878     } catch (std::out_of_range& e) {
45879       {
45880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45881       };
45882     } catch (std::exception& e) {
45883       {
45884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45885       };
45886     } catch (Dali::DaliException e) {
45887       {
45888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45889       };
45890     } catch (...) {
45891       {
45892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45893       };
45894     }
45895   }
45896
45897   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45898   return jresult;
45899 }
45900
45901
45902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45903   void * jresult ;
45904   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45905   std::size_t arg2 ;
45906   Dali::ImageDimensions arg3 ;
45907   Dali::FittingMode::Type arg4 ;
45908   Dali::SamplingMode::Type arg5 ;
45909   Dali::ImageDimensions *argp3 ;
45910   Dali::EncodedBufferImage result;
45911
45912   arg1 = (uint8_t *)jarg1;
45913   arg2 = (std::size_t)jarg2;
45914   argp3 = (Dali::ImageDimensions *)jarg3;
45915   if (!argp3) {
45916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45917     return 0;
45918   }
45919   arg3 = *argp3;
45920   arg4 = (Dali::FittingMode::Type)jarg4;
45921   arg5 = (Dali::SamplingMode::Type)jarg5;
45922   {
45923     try {
45924       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45925     } catch (std::out_of_range& e) {
45926       {
45927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45928       };
45929     } catch (std::exception& e) {
45930       {
45931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45932       };
45933     } catch (Dali::DaliException e) {
45934       {
45935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45936       };
45937     } catch (...) {
45938       {
45939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45940       };
45941     }
45942   }
45943
45944   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45945   return jresult;
45946 }
45947
45948
45949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45950   void * jresult ;
45951   Dali::BaseHandle arg1 ;
45952   Dali::BaseHandle *argp1 ;
45953   Dali::EncodedBufferImage result;
45954
45955   argp1 = (Dali::BaseHandle *)jarg1;
45956   if (!argp1) {
45957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45958     return 0;
45959   }
45960   arg1 = *argp1;
45961   {
45962     try {
45963       result = Dali::EncodedBufferImage::DownCast(arg1);
45964     } catch (std::out_of_range& e) {
45965       {
45966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45967       };
45968     } catch (std::exception& e) {
45969       {
45970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45971       };
45972     } catch (Dali::DaliException e) {
45973       {
45974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45975       };
45976     } catch (...) {
45977       {
45978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45979       };
45980     }
45981   }
45982
45983   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45984   return jresult;
45985 }
45986
45987
45988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45989   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45990
45991   arg1 = (Dali::EncodedBufferImage *)jarg1;
45992   {
45993     try {
45994       delete arg1;
45995     } catch (std::out_of_range& e) {
45996       {
45997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45998       };
45999     } catch (std::exception& e) {
46000       {
46001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46002       };
46003     } catch (Dali::DaliException e) {
46004       {
46005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46006       };
46007     } catch (...) {
46008       {
46009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46010       };
46011     }
46012   }
46013
46014 }
46015
46016
46017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
46018   void * jresult ;
46019   Dali::EncodedBufferImage *arg1 = 0 ;
46020   Dali::EncodedBufferImage *result = 0 ;
46021
46022   arg1 = (Dali::EncodedBufferImage *)jarg1;
46023   if (!arg1) {
46024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
46025     return 0;
46026   }
46027   {
46028     try {
46029       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
46030     } catch (std::out_of_range& e) {
46031       {
46032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46033       };
46034     } catch (std::exception& e) {
46035       {
46036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46037       };
46038     } catch (Dali::DaliException e) {
46039       {
46040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46041       };
46042     } catch (...) {
46043       {
46044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46045       };
46046     }
46047   }
46048
46049   jresult = (void *)result;
46050   return jresult;
46051 }
46052
46053
46054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
46055   void * jresult ;
46056   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
46057   Dali::EncodedBufferImage *arg2 = 0 ;
46058   Dali::EncodedBufferImage *result = 0 ;
46059
46060   arg1 = (Dali::EncodedBufferImage *)jarg1;
46061   arg2 = (Dali::EncodedBufferImage *)jarg2;
46062   if (!arg2) {
46063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
46064     return 0;
46065   }
46066   {
46067     try {
46068       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
46069     } catch (std::out_of_range& e) {
46070       {
46071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46072       };
46073     } catch (std::exception& e) {
46074       {
46075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46076       };
46077     } catch (Dali::DaliException e) {
46078       {
46079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46080       };
46081     } catch (...) {
46082       {
46083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46084       };
46085     }
46086   }
46087
46088   jresult = (void *)result;
46089   return jresult;
46090 }
46091
46092
46093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
46094   void * jresult ;
46095   Dali::NativeImage *result = 0 ;
46096
46097   {
46098     try {
46099       result = (Dali::NativeImage *)new Dali::NativeImage();
46100     } catch (std::out_of_range& e) {
46101       {
46102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46103       };
46104     } catch (std::exception& e) {
46105       {
46106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46107       };
46108     } catch (Dali::DaliException e) {
46109       {
46110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46111       };
46112     } catch (...) {
46113       {
46114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46115       };
46116     }
46117   }
46118
46119   jresult = (void *)result;
46120   return jresult;
46121 }
46122
46123
46124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
46125   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46126
46127   arg1 = (Dali::NativeImage *)jarg1;
46128   {
46129     try {
46130       delete arg1;
46131     } catch (std::out_of_range& e) {
46132       {
46133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46134       };
46135     } catch (std::exception& e) {
46136       {
46137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46138       };
46139     } catch (Dali::DaliException e) {
46140       {
46141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46142       };
46143     } catch (...) {
46144       {
46145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46146       };
46147     }
46148   }
46149
46150 }
46151
46152
46153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
46154   void * jresult ;
46155   Dali::NativeImage *arg1 = 0 ;
46156   Dali::NativeImage *result = 0 ;
46157
46158   arg1 = (Dali::NativeImage *)jarg1;
46159   if (!arg1) {
46160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46161     return 0;
46162   }
46163   {
46164     try {
46165       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
46166     } catch (std::out_of_range& e) {
46167       {
46168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46169       };
46170     } catch (std::exception& e) {
46171       {
46172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46173       };
46174     } catch (Dali::DaliException e) {
46175       {
46176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46177       };
46178     } catch (...) {
46179       {
46180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46181       };
46182     }
46183   }
46184
46185   jresult = (void *)result;
46186   return jresult;
46187 }
46188
46189
46190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
46191   void * jresult ;
46192   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46193   Dali::NativeImage *arg2 = 0 ;
46194   Dali::NativeImage *result = 0 ;
46195
46196   arg1 = (Dali::NativeImage *)jarg1;
46197   arg2 = (Dali::NativeImage *)jarg2;
46198   if (!arg2) {
46199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46200     return 0;
46201   }
46202   {
46203     try {
46204       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46205     } catch (std::out_of_range& e) {
46206       {
46207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46208       };
46209     } catch (std::exception& e) {
46210       {
46211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46212       };
46213     } catch (Dali::DaliException e) {
46214       {
46215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46216       };
46217     } catch (...) {
46218       {
46219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46220       };
46221     }
46222   }
46223
46224   jresult = (void *)result;
46225   return jresult;
46226 }
46227
46228
46229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46230   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46231
46232   arg1 = (Dali::NativeImage *)jarg1;
46233   {
46234     try {
46235       (arg1)->CreateGlTexture();
46236     } catch (std::out_of_range& e) {
46237       {
46238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46239       };
46240     } catch (std::exception& e) {
46241       {
46242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46243       };
46244     } catch (Dali::DaliException e) {
46245       {
46246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46247       };
46248     } catch (...) {
46249       {
46250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46251       };
46252     }
46253   }
46254
46255 }
46256
46257
46258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46259   void * jresult ;
46260   NativeImageInterface *arg1 = 0 ;
46261   Dali::NativeImage result;
46262
46263   arg1 = (NativeImageInterface *)jarg1;
46264   if (!arg1) {
46265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46266     return 0;
46267   }
46268   {
46269     try {
46270       result = Dali::NativeImage::New(*arg1);
46271     } catch (std::out_of_range& e) {
46272       {
46273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46274       };
46275     } catch (std::exception& e) {
46276       {
46277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46278       };
46279     } catch (Dali::DaliException e) {
46280       {
46281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46282       };
46283     } catch (...) {
46284       {
46285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46286       };
46287     }
46288   }
46289
46290   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46291   return jresult;
46292 }
46293
46294
46295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46296   void * jresult ;
46297   Dali::BaseHandle arg1 ;
46298   Dali::BaseHandle *argp1 ;
46299   Dali::NativeImage result;
46300
46301   argp1 = (Dali::BaseHandle *)jarg1;
46302   if (!argp1) {
46303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46304     return 0;
46305   }
46306   arg1 = *argp1;
46307   {
46308     try {
46309       result = Dali::NativeImage::DownCast(arg1);
46310     } catch (std::out_of_range& e) {
46311       {
46312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46313       };
46314     } catch (std::exception& e) {
46315       {
46316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46317       };
46318     } catch (Dali::DaliException e) {
46319       {
46320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46321       };
46322     } catch (...) {
46323       {
46324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46325       };
46326     }
46327   }
46328
46329   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46330   return jresult;
46331 }
46332
46333
46334 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46335   char * jresult ;
46336   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46337   char *result = 0 ;
46338
46339   arg1 = (Dali::NativeImage *)jarg1;
46340   {
46341     try {
46342       result = (char *)(arg1)->GetCustomFragmentPreFix();
46343     } catch (std::out_of_range& e) {
46344       {
46345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46346       };
46347     } catch (std::exception& e) {
46348       {
46349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46350       };
46351     } catch (Dali::DaliException e) {
46352       {
46353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46354       };
46355     } catch (...) {
46356       {
46357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46358       };
46359     }
46360   }
46361
46362   jresult = SWIG_csharp_string_callback((const char *)result);
46363   return jresult;
46364 }
46365
46366
46367 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46368   char * jresult ;
46369   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46370   char *result = 0 ;
46371
46372   arg1 = (Dali::NativeImage *)jarg1;
46373   {
46374     try {
46375       result = (char *)(arg1)->GetCustomSamplerTypename();
46376     } catch (std::out_of_range& e) {
46377       {
46378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46379       };
46380     } catch (std::exception& e) {
46381       {
46382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46383       };
46384     } catch (Dali::DaliException e) {
46385       {
46386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46387       };
46388     } catch (...) {
46389       {
46390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46391       };
46392     }
46393   }
46394
46395   jresult = SWIG_csharp_string_callback((const char *)result);
46396   return jresult;
46397 }
46398
46399
46400 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46401   unsigned int jresult ;
46402   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46403   bool result;
46404
46405   arg1 = (Dali::NativeImageInterface *)jarg1;
46406   {
46407     try {
46408       result = (bool)(arg1)->GlExtensionCreate();
46409     } catch (std::out_of_range& e) {
46410       {
46411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46412       };
46413     } catch (std::exception& e) {
46414       {
46415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46416       };
46417     } catch (Dali::DaliException e) {
46418       {
46419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46420       };
46421     } catch (...) {
46422       {
46423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46424       };
46425     }
46426   }
46427
46428   jresult = result;
46429   return jresult;
46430 }
46431
46432
46433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46434   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46435
46436   arg1 = (Dali::NativeImageInterface *)jarg1;
46437   {
46438     try {
46439       (arg1)->GlExtensionDestroy();
46440     } catch (std::out_of_range& e) {
46441       {
46442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46443       };
46444     } catch (std::exception& e) {
46445       {
46446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46447       };
46448     } catch (Dali::DaliException e) {
46449       {
46450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46451       };
46452     } catch (...) {
46453       {
46454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46455       };
46456     }
46457   }
46458
46459 }
46460
46461
46462 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46463   unsigned int jresult ;
46464   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46465   unsigned int result;
46466
46467   arg1 = (Dali::NativeImageInterface *)jarg1;
46468   {
46469     try {
46470       result = (unsigned int)(arg1)->TargetTexture();
46471     } catch (std::out_of_range& e) {
46472       {
46473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46474       };
46475     } catch (std::exception& e) {
46476       {
46477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46478       };
46479     } catch (Dali::DaliException e) {
46480       {
46481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46482       };
46483     } catch (...) {
46484       {
46485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46486       };
46487     }
46488   }
46489
46490   jresult = result;
46491   return jresult;
46492 }
46493
46494
46495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46496   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46497
46498   arg1 = (Dali::NativeImageInterface *)jarg1;
46499   {
46500     try {
46501       (arg1)->PrepareTexture();
46502     } catch (std::out_of_range& e) {
46503       {
46504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46505       };
46506     } catch (std::exception& e) {
46507       {
46508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46509       };
46510     } catch (Dali::DaliException e) {
46511       {
46512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46513       };
46514     } catch (...) {
46515       {
46516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46517       };
46518     }
46519   }
46520
46521 }
46522
46523
46524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46525   unsigned int jresult ;
46526   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46527   unsigned int result;
46528
46529   arg1 = (Dali::NativeImageInterface *)jarg1;
46530   {
46531     try {
46532       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46533     } catch (std::out_of_range& e) {
46534       {
46535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46536       };
46537     } catch (std::exception& e) {
46538       {
46539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46540       };
46541     } catch (Dali::DaliException e) {
46542       {
46543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46544       };
46545     } catch (...) {
46546       {
46547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46548       };
46549     }
46550   }
46551
46552   jresult = result;
46553   return jresult;
46554 }
46555
46556
46557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46558   unsigned int jresult ;
46559   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46560   unsigned int result;
46561
46562   arg1 = (Dali::NativeImageInterface *)jarg1;
46563   {
46564     try {
46565       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46566     } catch (std::out_of_range& e) {
46567       {
46568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46569       };
46570     } catch (std::exception& e) {
46571       {
46572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46573       };
46574     } catch (Dali::DaliException e) {
46575       {
46576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46577       };
46578     } catch (...) {
46579       {
46580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46581       };
46582     }
46583   }
46584
46585   jresult = result;
46586   return jresult;
46587 }
46588
46589
46590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46591   unsigned int jresult ;
46592   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46593   bool result;
46594
46595   arg1 = (Dali::NativeImageInterface *)jarg1;
46596   {
46597     try {
46598       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46599     } catch (std::out_of_range& e) {
46600       {
46601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46602       };
46603     } catch (std::exception& e) {
46604       {
46605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46606       };
46607     } catch (Dali::DaliException e) {
46608       {
46609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46610       };
46611     } catch (...) {
46612       {
46613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46614       };
46615     }
46616   }
46617
46618   jresult = result;
46619   return jresult;
46620 }
46621
46622
46623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46624   void * jresult ;
46625   std::string *arg1 = 0 ;
46626   Dali::ImageDimensions result;
46627
46628   if (!jarg1) {
46629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46630     return 0;
46631   }
46632   std::string arg1_str(jarg1);
46633   arg1 = &arg1_str;
46634   {
46635     try {
46636       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46637     } catch (std::out_of_range& e) {
46638       {
46639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46640       };
46641     } catch (std::exception& e) {
46642       {
46643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46644       };
46645     } catch (Dali::DaliException e) {
46646       {
46647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46648       };
46649     } catch (...) {
46650       {
46651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46652       };
46653     }
46654   }
46655
46656   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46657
46658   //argout typemap for const std::string&
46659
46660   return jresult;
46661 }
46662
46663
46664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46665   void * jresult ;
46666   Dali::ResourceImage *result = 0 ;
46667
46668   {
46669     try {
46670       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46671     } catch (std::out_of_range& e) {
46672       {
46673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46674       };
46675     } catch (std::exception& e) {
46676       {
46677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46678       };
46679     } catch (Dali::DaliException e) {
46680       {
46681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46682       };
46683     } catch (...) {
46684       {
46685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46686       };
46687     }
46688   }
46689
46690   jresult = (void *)result;
46691   return jresult;
46692 }
46693
46694
46695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46696   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46697
46698   arg1 = (Dali::ResourceImage *)jarg1;
46699   {
46700     try {
46701       delete arg1;
46702     } catch (std::out_of_range& e) {
46703       {
46704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46705       };
46706     } catch (std::exception& e) {
46707       {
46708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46709       };
46710     } catch (Dali::DaliException e) {
46711       {
46712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46713       };
46714     } catch (...) {
46715       {
46716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46717       };
46718     }
46719   }
46720
46721 }
46722
46723
46724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46725   void * jresult ;
46726   Dali::ResourceImage *arg1 = 0 ;
46727   Dali::ResourceImage *result = 0 ;
46728
46729   arg1 = (Dali::ResourceImage *)jarg1;
46730   if (!arg1) {
46731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46732     return 0;
46733   }
46734   {
46735     try {
46736       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46737     } catch (std::out_of_range& e) {
46738       {
46739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46740       };
46741     } catch (std::exception& e) {
46742       {
46743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46744       };
46745     } catch (Dali::DaliException e) {
46746       {
46747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46748       };
46749     } catch (...) {
46750       {
46751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46752       };
46753     }
46754   }
46755
46756   jresult = (void *)result;
46757   return jresult;
46758 }
46759
46760
46761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46762   void * jresult ;
46763   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46764   Dali::ResourceImage *arg2 = 0 ;
46765   Dali::ResourceImage *result = 0 ;
46766
46767   arg1 = (Dali::ResourceImage *)jarg1;
46768   arg2 = (Dali::ResourceImage *)jarg2;
46769   if (!arg2) {
46770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46771     return 0;
46772   }
46773   {
46774     try {
46775       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46776     } catch (std::out_of_range& e) {
46777       {
46778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46779       };
46780     } catch (std::exception& e) {
46781       {
46782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46783       };
46784     } catch (Dali::DaliException e) {
46785       {
46786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46787       };
46788     } catch (...) {
46789       {
46790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46791       };
46792     }
46793   }
46794
46795   jresult = (void *)result;
46796   return jresult;
46797 }
46798
46799
46800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46801   void * jresult ;
46802   std::string *arg1 = 0 ;
46803   bool arg2 ;
46804   Dali::ResourceImage result;
46805
46806   if (!jarg1) {
46807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46808     return 0;
46809   }
46810   std::string arg1_str(jarg1);
46811   arg1 = &arg1_str;
46812   arg2 = jarg2 ? true : false;
46813   {
46814     try {
46815       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46816     } catch (std::out_of_range& e) {
46817       {
46818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46819       };
46820     } catch (std::exception& e) {
46821       {
46822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46823       };
46824     } catch (Dali::DaliException e) {
46825       {
46826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46827       };
46828     } catch (...) {
46829       {
46830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46831       };
46832     }
46833   }
46834
46835   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46836
46837   //argout typemap for const std::string&
46838
46839   return jresult;
46840 }
46841
46842
46843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46844   void * jresult ;
46845   std::string *arg1 = 0 ;
46846   Dali::ResourceImage result;
46847
46848   if (!jarg1) {
46849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46850     return 0;
46851   }
46852   std::string arg1_str(jarg1);
46853   arg1 = &arg1_str;
46854   {
46855     try {
46856       result = Dali::ResourceImage::New((std::string const &)*arg1);
46857     } catch (std::out_of_range& e) {
46858       {
46859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46860       };
46861     } catch (std::exception& e) {
46862       {
46863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46864       };
46865     } catch (Dali::DaliException e) {
46866       {
46867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46868       };
46869     } catch (...) {
46870       {
46871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46872       };
46873     }
46874   }
46875
46876   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46877
46878   //argout typemap for const std::string&
46879
46880   return jresult;
46881 }
46882
46883
46884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46885   void * jresult ;
46886   std::string *arg1 = 0 ;
46887   Dali::ImageDimensions arg2 ;
46888   Dali::FittingMode::Type arg3 ;
46889   Dali::SamplingMode::Type arg4 ;
46890   bool arg5 ;
46891   Dali::ImageDimensions *argp2 ;
46892   Dali::ResourceImage result;
46893
46894   if (!jarg1) {
46895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46896     return 0;
46897   }
46898   std::string arg1_str(jarg1);
46899   arg1 = &arg1_str;
46900   argp2 = (Dali::ImageDimensions *)jarg2;
46901   if (!argp2) {
46902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46903     return 0;
46904   }
46905   arg2 = *argp2;
46906   arg3 = (Dali::FittingMode::Type)jarg3;
46907   arg4 = (Dali::SamplingMode::Type)jarg4;
46908   arg5 = jarg5 ? true : false;
46909   {
46910     try {
46911       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46912     } catch (std::out_of_range& e) {
46913       {
46914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46915       };
46916     } catch (std::exception& e) {
46917       {
46918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46919       };
46920     } catch (Dali::DaliException e) {
46921       {
46922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46923       };
46924     } catch (...) {
46925       {
46926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46927       };
46928     }
46929   }
46930
46931   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46932
46933   //argout typemap for const std::string&
46934
46935   return jresult;
46936 }
46937
46938
46939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46940   void * jresult ;
46941   std::string *arg1 = 0 ;
46942   Dali::ImageDimensions arg2 ;
46943   Dali::FittingMode::Type arg3 ;
46944   Dali::SamplingMode::Type arg4 ;
46945   Dali::ImageDimensions *argp2 ;
46946   Dali::ResourceImage result;
46947
46948   if (!jarg1) {
46949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46950     return 0;
46951   }
46952   std::string arg1_str(jarg1);
46953   arg1 = &arg1_str;
46954   argp2 = (Dali::ImageDimensions *)jarg2;
46955   if (!argp2) {
46956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46957     return 0;
46958   }
46959   arg2 = *argp2;
46960   arg3 = (Dali::FittingMode::Type)jarg3;
46961   arg4 = (Dali::SamplingMode::Type)jarg4;
46962   {
46963     try {
46964       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46965     } catch (std::out_of_range& e) {
46966       {
46967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46968       };
46969     } catch (std::exception& e) {
46970       {
46971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46972       };
46973     } catch (Dali::DaliException e) {
46974       {
46975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46976       };
46977     } catch (...) {
46978       {
46979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46980       };
46981     }
46982   }
46983
46984   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46985
46986   //argout typemap for const std::string&
46987
46988   return jresult;
46989 }
46990
46991
46992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46993   void * jresult ;
46994   std::string *arg1 = 0 ;
46995   Dali::ImageDimensions arg2 ;
46996   Dali::FittingMode::Type arg3 ;
46997   Dali::ImageDimensions *argp2 ;
46998   Dali::ResourceImage result;
46999
47000   if (!jarg1) {
47001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47002     return 0;
47003   }
47004   std::string arg1_str(jarg1);
47005   arg1 = &arg1_str;
47006   argp2 = (Dali::ImageDimensions *)jarg2;
47007   if (!argp2) {
47008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
47009     return 0;
47010   }
47011   arg2 = *argp2;
47012   arg3 = (Dali::FittingMode::Type)jarg3;
47013   {
47014     try {
47015       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
47016     } catch (std::out_of_range& e) {
47017       {
47018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47019       };
47020     } catch (std::exception& e) {
47021       {
47022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47023       };
47024     } catch (Dali::DaliException e) {
47025       {
47026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47027       };
47028     } catch (...) {
47029       {
47030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47031       };
47032     }
47033   }
47034
47035   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47036
47037   //argout typemap for const std::string&
47038
47039   return jresult;
47040 }
47041
47042
47043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
47044   void * jresult ;
47045   std::string *arg1 = 0 ;
47046   Dali::ImageDimensions arg2 ;
47047   Dali::ImageDimensions *argp2 ;
47048   Dali::ResourceImage result;
47049
47050   if (!jarg1) {
47051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47052     return 0;
47053   }
47054   std::string arg1_str(jarg1);
47055   arg1 = &arg1_str;
47056   argp2 = (Dali::ImageDimensions *)jarg2;
47057   if (!argp2) {
47058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
47059     return 0;
47060   }
47061   arg2 = *argp2;
47062   {
47063     try {
47064       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
47065     } catch (std::out_of_range& e) {
47066       {
47067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47068       };
47069     } catch (std::exception& e) {
47070       {
47071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47072       };
47073     } catch (Dali::DaliException e) {
47074       {
47075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47076       };
47077     } catch (...) {
47078       {
47079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47080       };
47081     }
47082   }
47083
47084   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47085
47086   //argout typemap for const std::string&
47087
47088   return jresult;
47089 }
47090
47091
47092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
47093   void * jresult ;
47094   Dali::BaseHandle arg1 ;
47095   Dali::BaseHandle *argp1 ;
47096   Dali::ResourceImage result;
47097
47098   argp1 = (Dali::BaseHandle *)jarg1;
47099   if (!argp1) {
47100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47101     return 0;
47102   }
47103   arg1 = *argp1;
47104   {
47105     try {
47106       result = Dali::ResourceImage::DownCast(arg1);
47107     } catch (std::out_of_range& e) {
47108       {
47109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47110       };
47111     } catch (std::exception& e) {
47112       {
47113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47114       };
47115     } catch (Dali::DaliException e) {
47116       {
47117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47118       };
47119     } catch (...) {
47120       {
47121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47122       };
47123     }
47124   }
47125
47126   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47127   return jresult;
47128 }
47129
47130
47131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
47132   int jresult ;
47133   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47134   Dali::LoadingState result;
47135
47136   arg1 = (Dali::ResourceImage *)jarg1;
47137   {
47138     try {
47139       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
47140     } catch (std::out_of_range& e) {
47141       {
47142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47143       };
47144     } catch (std::exception& e) {
47145       {
47146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47147       };
47148     } catch (Dali::DaliException e) {
47149       {
47150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47151       };
47152     } catch (...) {
47153       {
47154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47155       };
47156     }
47157   }
47158
47159   jresult = (int)result;
47160   return jresult;
47161 }
47162
47163
47164 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
47165   char * jresult ;
47166   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47167   std::string result;
47168
47169   arg1 = (Dali::ResourceImage *)jarg1;
47170   {
47171     try {
47172       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47173     } catch (std::out_of_range& e) {
47174       {
47175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47176       };
47177     } catch (std::exception& e) {
47178       {
47179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47180       };
47181     } catch (Dali::DaliException e) {
47182       {
47183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47184       };
47185     } catch (...) {
47186       {
47187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47188       };
47189     }
47190   }
47191
47192   jresult = SWIG_csharp_string_callback((&result)->c_str());
47193   return jresult;
47194 }
47195
47196
47197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47198   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47199
47200   arg1 = (Dali::ResourceImage *)jarg1;
47201   {
47202     try {
47203       (arg1)->Reload();
47204     } catch (std::out_of_range& e) {
47205       {
47206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47207       };
47208     } catch (std::exception& e) {
47209       {
47210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47211       };
47212     } catch (Dali::DaliException e) {
47213       {
47214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47215       };
47216     } catch (...) {
47217       {
47218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47219       };
47220     }
47221   }
47222
47223 }
47224
47225
47226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47227   void * jresult ;
47228   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47229   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47230
47231   arg1 = (Dali::ResourceImage *)jarg1;
47232   {
47233     try {
47234       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47235     } catch (std::out_of_range& e) {
47236       {
47237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47238       };
47239     } catch (std::exception& e) {
47240       {
47241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47242       };
47243     } catch (Dali::DaliException e) {
47244       {
47245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47246       };
47247     } catch (...) {
47248       {
47249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47250       };
47251     }
47252   }
47253
47254   jresult = (void *)result;
47255   return jresult;
47256 }
47257
47258
47259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47260   void * jresult ;
47261   Dali::FrameBufferImage *result = 0 ;
47262
47263   {
47264     try {
47265       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47266     } catch (std::out_of_range& e) {
47267       {
47268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47269       };
47270     } catch (std::exception& e) {
47271       {
47272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47273       };
47274     } catch (Dali::DaliException e) {
47275       {
47276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47277       };
47278     } catch (...) {
47279       {
47280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47281       };
47282     }
47283   }
47284
47285   jresult = (void *)result;
47286   return jresult;
47287 }
47288
47289
47290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47291   void * jresult ;
47292   unsigned int arg1 ;
47293   unsigned int arg2 ;
47294   Dali::Pixel::Format arg3 ;
47295   Dali::RenderBuffer::Format arg4 ;
47296   Dali::FrameBufferImage result;
47297
47298   arg1 = (unsigned int)jarg1;
47299   arg2 = (unsigned int)jarg2;
47300   arg3 = (Dali::Pixel::Format)jarg3;
47301   arg4 = (Dali::RenderBuffer::Format)jarg4;
47302   {
47303     try {
47304       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47305     } catch (std::out_of_range& e) {
47306       {
47307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47308       };
47309     } catch (std::exception& e) {
47310       {
47311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47312       };
47313     } catch (Dali::DaliException e) {
47314       {
47315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47316       };
47317     } catch (...) {
47318       {
47319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47320       };
47321     }
47322   }
47323
47324   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47325   return jresult;
47326 }
47327
47328
47329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47330   void * jresult ;
47331   unsigned int arg1 ;
47332   unsigned int arg2 ;
47333   Dali::Pixel::Format arg3 ;
47334   Dali::FrameBufferImage result;
47335
47336   arg1 = (unsigned int)jarg1;
47337   arg2 = (unsigned int)jarg2;
47338   arg3 = (Dali::Pixel::Format)jarg3;
47339   {
47340     try {
47341       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47342     } catch (std::out_of_range& e) {
47343       {
47344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47345       };
47346     } catch (std::exception& e) {
47347       {
47348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47349       };
47350     } catch (Dali::DaliException e) {
47351       {
47352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47353       };
47354     } catch (...) {
47355       {
47356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47357       };
47358     }
47359   }
47360
47361   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47362   return jresult;
47363 }
47364
47365
47366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47367   void * jresult ;
47368   unsigned int arg1 ;
47369   unsigned int arg2 ;
47370   Dali::FrameBufferImage result;
47371
47372   arg1 = (unsigned int)jarg1;
47373   arg2 = (unsigned int)jarg2;
47374   {
47375     try {
47376       result = Dali::FrameBufferImage::New(arg1,arg2);
47377     } catch (std::out_of_range& e) {
47378       {
47379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47380       };
47381     } catch (std::exception& e) {
47382       {
47383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47384       };
47385     } catch (Dali::DaliException e) {
47386       {
47387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47388       };
47389     } catch (...) {
47390       {
47391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47392       };
47393     }
47394   }
47395
47396   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47397   return jresult;
47398 }
47399
47400
47401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47402   void * jresult ;
47403   unsigned int arg1 ;
47404   Dali::FrameBufferImage result;
47405
47406   arg1 = (unsigned int)jarg1;
47407   {
47408     try {
47409       result = Dali::FrameBufferImage::New(arg1);
47410     } catch (std::out_of_range& e) {
47411       {
47412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47413       };
47414     } catch (std::exception& e) {
47415       {
47416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47417       };
47418     } catch (Dali::DaliException e) {
47419       {
47420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47421       };
47422     } catch (...) {
47423       {
47424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47425       };
47426     }
47427   }
47428
47429   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47430   return jresult;
47431 }
47432
47433
47434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47435   void * jresult ;
47436   Dali::FrameBufferImage result;
47437
47438   {
47439     try {
47440       result = Dali::FrameBufferImage::New();
47441     } catch (std::out_of_range& e) {
47442       {
47443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47444       };
47445     } catch (std::exception& e) {
47446       {
47447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47448       };
47449     } catch (Dali::DaliException e) {
47450       {
47451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47452       };
47453     } catch (...) {
47454       {
47455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47456       };
47457     }
47458   }
47459
47460   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47461   return jresult;
47462 }
47463
47464
47465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47466   void * jresult ;
47467   Dali::NativeImageInterface *arg1 = 0 ;
47468   Dali::FrameBufferImage result;
47469
47470   arg1 = (Dali::NativeImageInterface *)jarg1;
47471   if (!arg1) {
47472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47473     return 0;
47474   }
47475   {
47476     try {
47477       result = Dali::FrameBufferImage::New(*arg1);
47478     } catch (std::out_of_range& e) {
47479       {
47480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47481       };
47482     } catch (std::exception& e) {
47483       {
47484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47485       };
47486     } catch (Dali::DaliException e) {
47487       {
47488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47489       };
47490     } catch (...) {
47491       {
47492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47493       };
47494     }
47495   }
47496
47497   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47498   return jresult;
47499 }
47500
47501
47502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47503   void * jresult ;
47504   Dali::BaseHandle arg1 ;
47505   Dali::BaseHandle *argp1 ;
47506   Dali::FrameBufferImage result;
47507
47508   argp1 = (Dali::BaseHandle *)jarg1;
47509   if (!argp1) {
47510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47511     return 0;
47512   }
47513   arg1 = *argp1;
47514   {
47515     try {
47516       result = Dali::FrameBufferImage::DownCast(arg1);
47517     } catch (std::out_of_range& e) {
47518       {
47519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47520       };
47521     } catch (std::exception& e) {
47522       {
47523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47524       };
47525     } catch (Dali::DaliException e) {
47526       {
47527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47528       };
47529     } catch (...) {
47530       {
47531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47532       };
47533     }
47534   }
47535
47536   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47537   return jresult;
47538 }
47539
47540
47541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47542   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47543
47544   arg1 = (Dali::FrameBufferImage *)jarg1;
47545   {
47546     try {
47547       delete arg1;
47548     } catch (std::out_of_range& e) {
47549       {
47550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47551       };
47552     } catch (std::exception& e) {
47553       {
47554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47555       };
47556     } catch (Dali::DaliException e) {
47557       {
47558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47559       };
47560     } catch (...) {
47561       {
47562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47563       };
47564     }
47565   }
47566
47567 }
47568
47569
47570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47571   void * jresult ;
47572   Dali::FrameBufferImage *arg1 = 0 ;
47573   Dali::FrameBufferImage *result = 0 ;
47574
47575   arg1 = (Dali::FrameBufferImage *)jarg1;
47576   if (!arg1) {
47577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47578     return 0;
47579   }
47580   {
47581     try {
47582       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47583     } catch (std::out_of_range& e) {
47584       {
47585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47586       };
47587     } catch (std::exception& e) {
47588       {
47589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47590       };
47591     } catch (Dali::DaliException e) {
47592       {
47593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47594       };
47595     } catch (...) {
47596       {
47597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47598       };
47599     }
47600   }
47601
47602   jresult = (void *)result;
47603   return jresult;
47604 }
47605
47606
47607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47608   void * jresult ;
47609   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47610   Dali::FrameBufferImage *arg2 = 0 ;
47611   Dali::FrameBufferImage *result = 0 ;
47612
47613   arg1 = (Dali::FrameBufferImage *)jarg1;
47614   arg2 = (Dali::FrameBufferImage *)jarg2;
47615   if (!arg2) {
47616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47617     return 0;
47618   }
47619   {
47620     try {
47621       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47622     } catch (std::out_of_range& e) {
47623       {
47624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47625       };
47626     } catch (std::exception& e) {
47627       {
47628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47629       };
47630     } catch (Dali::DaliException e) {
47631       {
47632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47633       };
47634     } catch (...) {
47635       {
47636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47637       };
47638     }
47639   }
47640
47641   jresult = (void *)result;
47642   return jresult;
47643 }
47644
47645
47646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47647   void * jresult ;
47648   Dali::NinePatchImage *result = 0 ;
47649
47650   {
47651     try {
47652       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47653     } catch (std::out_of_range& e) {
47654       {
47655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47656       };
47657     } catch (std::exception& e) {
47658       {
47659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47660       };
47661     } catch (Dali::DaliException e) {
47662       {
47663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47664       };
47665     } catch (...) {
47666       {
47667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47668       };
47669     }
47670   }
47671
47672   jresult = (void *)result;
47673   return jresult;
47674 }
47675
47676
47677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47678   void * jresult ;
47679   std::string *arg1 = 0 ;
47680   Dali::NinePatchImage result;
47681
47682   if (!jarg1) {
47683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47684     return 0;
47685   }
47686   std::string arg1_str(jarg1);
47687   arg1 = &arg1_str;
47688   {
47689     try {
47690       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47691     } catch (std::out_of_range& e) {
47692       {
47693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47694       };
47695     } catch (std::exception& e) {
47696       {
47697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47698       };
47699     } catch (Dali::DaliException e) {
47700       {
47701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47702       };
47703     } catch (...) {
47704       {
47705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47706       };
47707     }
47708   }
47709
47710   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47711
47712   //argout typemap for const std::string&
47713
47714   return jresult;
47715 }
47716
47717
47718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47719   void * jresult ;
47720   Dali::BaseHandle arg1 ;
47721   Dali::BaseHandle *argp1 ;
47722   Dali::NinePatchImage result;
47723
47724   argp1 = (Dali::BaseHandle *)jarg1;
47725   if (!argp1) {
47726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47727     return 0;
47728   }
47729   arg1 = *argp1;
47730   {
47731     try {
47732       result = Dali::NinePatchImage::DownCast(arg1);
47733     } catch (std::out_of_range& e) {
47734       {
47735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47736       };
47737     } catch (std::exception& e) {
47738       {
47739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47740       };
47741     } catch (Dali::DaliException e) {
47742       {
47743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47744       };
47745     } catch (...) {
47746       {
47747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47748       };
47749     }
47750   }
47751
47752   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47753   return jresult;
47754 }
47755
47756
47757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47758   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47759
47760   arg1 = (Dali::NinePatchImage *)jarg1;
47761   {
47762     try {
47763       delete arg1;
47764     } catch (std::out_of_range& e) {
47765       {
47766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47767       };
47768     } catch (std::exception& e) {
47769       {
47770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47771       };
47772     } catch (Dali::DaliException e) {
47773       {
47774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47775       };
47776     } catch (...) {
47777       {
47778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47779       };
47780     }
47781   }
47782
47783 }
47784
47785
47786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47787   void * jresult ;
47788   Dali::NinePatchImage *arg1 = 0 ;
47789   Dali::NinePatchImage *result = 0 ;
47790
47791   arg1 = (Dali::NinePatchImage *)jarg1;
47792   if (!arg1) {
47793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47794     return 0;
47795   }
47796   {
47797     try {
47798       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47799     } catch (std::out_of_range& e) {
47800       {
47801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47802       };
47803     } catch (std::exception& e) {
47804       {
47805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47806       };
47807     } catch (Dali::DaliException e) {
47808       {
47809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47810       };
47811     } catch (...) {
47812       {
47813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47814       };
47815     }
47816   }
47817
47818   jresult = (void *)result;
47819   return jresult;
47820 }
47821
47822
47823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47824   void * jresult ;
47825   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47826   Dali::NinePatchImage *arg2 = 0 ;
47827   Dali::NinePatchImage *result = 0 ;
47828
47829   arg1 = (Dali::NinePatchImage *)jarg1;
47830   arg2 = (Dali::NinePatchImage *)jarg2;
47831   if (!arg2) {
47832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47833     return 0;
47834   }
47835   {
47836     try {
47837       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47838     } catch (std::out_of_range& e) {
47839       {
47840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47841       };
47842     } catch (std::exception& e) {
47843       {
47844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47845       };
47846     } catch (Dali::DaliException e) {
47847       {
47848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47849       };
47850     } catch (...) {
47851       {
47852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47853       };
47854     }
47855   }
47856
47857   jresult = (void *)result;
47858   return jresult;
47859 }
47860
47861
47862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47863   void * jresult ;
47864   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47865   Dali::Vector4 result;
47866
47867   arg1 = (Dali::NinePatchImage *)jarg1;
47868   {
47869     try {
47870       result = (arg1)->GetStretchBorders();
47871     } catch (std::out_of_range& e) {
47872       {
47873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47874       };
47875     } catch (std::exception& e) {
47876       {
47877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47878       };
47879     } catch (Dali::DaliException e) {
47880       {
47881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47882       };
47883     } catch (...) {
47884       {
47885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47886       };
47887     }
47888   }
47889
47890   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47891   return jresult;
47892 }
47893
47894
47895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47896   void * jresult ;
47897   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47898   Dali::NinePatchImage::StretchRanges *result = 0 ;
47899
47900   arg1 = (Dali::NinePatchImage *)jarg1;
47901   {
47902     try {
47903       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47904     } catch (std::out_of_range& e) {
47905       {
47906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47907       };
47908     } catch (std::exception& e) {
47909       {
47910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47911       };
47912     } catch (Dali::DaliException e) {
47913       {
47914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47915       };
47916     } catch (...) {
47917       {
47918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47919       };
47920     }
47921   }
47922
47923   jresult = (void *)result;
47924   return jresult;
47925 }
47926
47927
47928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47929   void * jresult ;
47930   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47931   Dali::NinePatchImage::StretchRanges *result = 0 ;
47932
47933   arg1 = (Dali::NinePatchImage *)jarg1;
47934   {
47935     try {
47936       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47937     } catch (std::out_of_range& e) {
47938       {
47939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47940       };
47941     } catch (std::exception& e) {
47942       {
47943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47944       };
47945     } catch (Dali::DaliException e) {
47946       {
47947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47948       };
47949     } catch (...) {
47950       {
47951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47952       };
47953     }
47954   }
47955
47956   jresult = (void *)result;
47957   return jresult;
47958 }
47959
47960
47961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47962   void * jresult ;
47963   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47964   Dali::Rect< int > result;
47965
47966   arg1 = (Dali::NinePatchImage *)jarg1;
47967   {
47968     try {
47969       result = (arg1)->GetChildRectangle();
47970     } catch (std::out_of_range& e) {
47971       {
47972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47973       };
47974     } catch (std::exception& e) {
47975       {
47976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47977       };
47978     } catch (Dali::DaliException e) {
47979       {
47980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47981       };
47982     } catch (...) {
47983       {
47984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47985       };
47986     }
47987   }
47988
47989   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47990   return jresult;
47991 }
47992
47993
47994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47995   void * jresult ;
47996   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47997   Dali::BufferImage result;
47998
47999   arg1 = (Dali::NinePatchImage *)jarg1;
48000   {
48001     try {
48002       result = (arg1)->CreateCroppedBufferImage();
48003     } catch (std::out_of_range& e) {
48004       {
48005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48006       };
48007     } catch (std::exception& e) {
48008       {
48009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48010       };
48011     } catch (Dali::DaliException e) {
48012       {
48013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48014       };
48015     } catch (...) {
48016       {
48017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48018       };
48019     }
48020   }
48021
48022   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
48023   return jresult;
48024 }
48025
48026
48027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
48028   unsigned int jresult ;
48029   std::string *arg1 = 0 ;
48030   bool result;
48031
48032   if (!jarg1) {
48033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48034     return 0;
48035   }
48036   std::string arg1_str(jarg1);
48037   arg1 = &arg1_str;
48038   {
48039     try {
48040       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
48041     } catch (std::out_of_range& e) {
48042       {
48043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48044       };
48045     } catch (std::exception& e) {
48046       {
48047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48048       };
48049     } catch (Dali::DaliException e) {
48050       {
48051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48052       };
48053     } catch (...) {
48054       {
48055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48056       };
48057     }
48058   }
48059
48060   jresult = result;
48061
48062   //argout typemap for const std::string&
48063
48064   return jresult;
48065 }
48066
48067
48068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
48069   int jresult ;
48070   int result;
48071
48072   result = (int)Dali::CameraActor::Property::TYPE;
48073   jresult = (int)result;
48074   return jresult;
48075 }
48076
48077
48078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
48079   int jresult ;
48080   int result;
48081
48082   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
48083   jresult = (int)result;
48084   return jresult;
48085 }
48086
48087
48088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
48089   int jresult ;
48090   int result;
48091
48092   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
48093   jresult = (int)result;
48094   return jresult;
48095 }
48096
48097
48098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
48099   int jresult ;
48100   int result;
48101
48102   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
48103   jresult = (int)result;
48104   return jresult;
48105 }
48106
48107
48108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
48109   int jresult ;
48110   int result;
48111
48112   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
48113   jresult = (int)result;
48114   return jresult;
48115 }
48116
48117
48118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
48119   int jresult ;
48120   int result;
48121
48122   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
48123   jresult = (int)result;
48124   return jresult;
48125 }
48126
48127
48128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
48129   int jresult ;
48130   int result;
48131
48132   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
48133   jresult = (int)result;
48134   return jresult;
48135 }
48136
48137
48138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
48139   int jresult ;
48140   int result;
48141
48142   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
48143   jresult = (int)result;
48144   return jresult;
48145 }
48146
48147
48148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
48149   int jresult ;
48150   int result;
48151
48152   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
48153   jresult = (int)result;
48154   return jresult;
48155 }
48156
48157
48158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
48159   int jresult ;
48160   int result;
48161
48162   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
48163   jresult = (int)result;
48164   return jresult;
48165 }
48166
48167
48168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
48169   int jresult ;
48170   int result;
48171
48172   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48173   jresult = (int)result;
48174   return jresult;
48175 }
48176
48177
48178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48179   int jresult ;
48180   int result;
48181
48182   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48183   jresult = (int)result;
48184   return jresult;
48185 }
48186
48187
48188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48189   int jresult ;
48190   int result;
48191
48192   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48193   jresult = (int)result;
48194   return jresult;
48195 }
48196
48197
48198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48199   int jresult ;
48200   int result;
48201
48202   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48203   jresult = (int)result;
48204   return jresult;
48205 }
48206
48207
48208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48209   void * jresult ;
48210   Dali::CameraActor::Property *result = 0 ;
48211
48212   {
48213     try {
48214       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48215     } catch (std::out_of_range& e) {
48216       {
48217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48218       };
48219     } catch (std::exception& e) {
48220       {
48221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48222       };
48223     } catch (Dali::DaliException e) {
48224       {
48225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48226       };
48227     } catch (...) {
48228       {
48229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48230       };
48231     }
48232   }
48233
48234   jresult = (void *)result;
48235   return jresult;
48236 }
48237
48238
48239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48240   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48241
48242   arg1 = (Dali::CameraActor::Property *)jarg1;
48243   {
48244     try {
48245       delete arg1;
48246     } catch (std::out_of_range& e) {
48247       {
48248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48249       };
48250     } catch (std::exception& e) {
48251       {
48252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48253       };
48254     } catch (Dali::DaliException e) {
48255       {
48256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48257       };
48258     } catch (...) {
48259       {
48260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48261       };
48262     }
48263   }
48264
48265 }
48266
48267
48268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48269   void * jresult ;
48270   Dali::CameraActor *result = 0 ;
48271
48272   {
48273     try {
48274       result = (Dali::CameraActor *)new Dali::CameraActor();
48275     } catch (std::out_of_range& e) {
48276       {
48277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48278       };
48279     } catch (std::exception& e) {
48280       {
48281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48282       };
48283     } catch (Dali::DaliException e) {
48284       {
48285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48286       };
48287     } catch (...) {
48288       {
48289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48290       };
48291     }
48292   }
48293
48294   jresult = (void *)result;
48295   return jresult;
48296 }
48297
48298
48299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48300   void * jresult ;
48301   Dali::CameraActor result;
48302
48303   {
48304     try {
48305       result = Dali::CameraActor::New();
48306     } catch (std::out_of_range& e) {
48307       {
48308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48309       };
48310     } catch (std::exception& e) {
48311       {
48312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48313       };
48314     } catch (Dali::DaliException e) {
48315       {
48316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48317       };
48318     } catch (...) {
48319       {
48320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48321       };
48322     }
48323   }
48324
48325   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48326   return jresult;
48327 }
48328
48329
48330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48331   void * jresult ;
48332   Dali::Size *arg1 = 0 ;
48333   Dali::CameraActor result;
48334
48335   arg1 = (Dali::Size *)jarg1;
48336   if (!arg1) {
48337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48338     return 0;
48339   }
48340   {
48341     try {
48342       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48343     } catch (std::out_of_range& e) {
48344       {
48345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48346       };
48347     } catch (std::exception& e) {
48348       {
48349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48350       };
48351     } catch (Dali::DaliException e) {
48352       {
48353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48354       };
48355     } catch (...) {
48356       {
48357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48358       };
48359     }
48360   }
48361
48362   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48363   return jresult;
48364 }
48365
48366
48367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48368   void * jresult ;
48369   Dali::BaseHandle arg1 ;
48370   Dali::BaseHandle *argp1 ;
48371   Dali::CameraActor result;
48372
48373   argp1 = (Dali::BaseHandle *)jarg1;
48374   if (!argp1) {
48375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48376     return 0;
48377   }
48378   arg1 = *argp1;
48379   {
48380     try {
48381       result = Dali::CameraActor::DownCast(arg1);
48382     } catch (std::out_of_range& e) {
48383       {
48384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48385       };
48386     } catch (std::exception& e) {
48387       {
48388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48389       };
48390     } catch (Dali::DaliException e) {
48391       {
48392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48393       };
48394     } catch (...) {
48395       {
48396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48397       };
48398     }
48399   }
48400
48401   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48402   return jresult;
48403 }
48404
48405
48406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48407   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48408
48409   arg1 = (Dali::CameraActor *)jarg1;
48410   {
48411     try {
48412       delete arg1;
48413     } catch (std::out_of_range& e) {
48414       {
48415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48416       };
48417     } catch (std::exception& e) {
48418       {
48419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48420       };
48421     } catch (Dali::DaliException e) {
48422       {
48423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48424       };
48425     } catch (...) {
48426       {
48427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48428       };
48429     }
48430   }
48431
48432 }
48433
48434
48435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48436   void * jresult ;
48437   Dali::CameraActor *arg1 = 0 ;
48438   Dali::CameraActor *result = 0 ;
48439
48440   arg1 = (Dali::CameraActor *)jarg1;
48441   if (!arg1) {
48442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48443     return 0;
48444   }
48445   {
48446     try {
48447       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48448     } catch (std::out_of_range& e) {
48449       {
48450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48451       };
48452     } catch (std::exception& e) {
48453       {
48454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48455       };
48456     } catch (Dali::DaliException e) {
48457       {
48458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48459       };
48460     } catch (...) {
48461       {
48462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48463       };
48464     }
48465   }
48466
48467   jresult = (void *)result;
48468   return jresult;
48469 }
48470
48471
48472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48473   void * jresult ;
48474   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48475   Dali::CameraActor *arg2 = 0 ;
48476   Dali::CameraActor *result = 0 ;
48477
48478   arg1 = (Dali::CameraActor *)jarg1;
48479   arg2 = (Dali::CameraActor *)jarg2;
48480   if (!arg2) {
48481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48482     return 0;
48483   }
48484   {
48485     try {
48486       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48487     } catch (std::out_of_range& e) {
48488       {
48489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48490       };
48491     } catch (std::exception& e) {
48492       {
48493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48494       };
48495     } catch (Dali::DaliException e) {
48496       {
48497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48498       };
48499     } catch (...) {
48500       {
48501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48502       };
48503     }
48504   }
48505
48506   jresult = (void *)result;
48507   return jresult;
48508 }
48509
48510
48511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48512   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48513   Dali::Camera::Type arg2 ;
48514
48515   arg1 = (Dali::CameraActor *)jarg1;
48516   arg2 = (Dali::Camera::Type)jarg2;
48517   {
48518     try {
48519       (arg1)->SetType(arg2);
48520     } catch (std::out_of_range& e) {
48521       {
48522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48523       };
48524     } catch (std::exception& e) {
48525       {
48526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48527       };
48528     } catch (Dali::DaliException e) {
48529       {
48530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48531       };
48532     } catch (...) {
48533       {
48534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48535       };
48536     }
48537   }
48538
48539 }
48540
48541
48542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48543   int jresult ;
48544   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48545   Dali::Camera::Type result;
48546
48547   arg1 = (Dali::CameraActor *)jarg1;
48548   {
48549     try {
48550       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48551     } catch (std::out_of_range& e) {
48552       {
48553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48554       };
48555     } catch (std::exception& e) {
48556       {
48557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48558       };
48559     } catch (Dali::DaliException e) {
48560       {
48561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48562       };
48563     } catch (...) {
48564       {
48565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48566       };
48567     }
48568   }
48569
48570   jresult = (int)result;
48571   return jresult;
48572 }
48573
48574
48575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48576   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48577   Dali::Camera::ProjectionMode arg2 ;
48578
48579   arg1 = (Dali::CameraActor *)jarg1;
48580   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48581   {
48582     try {
48583       (arg1)->SetProjectionMode(arg2);
48584     } catch (std::out_of_range& e) {
48585       {
48586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48587       };
48588     } catch (std::exception& e) {
48589       {
48590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48591       };
48592     } catch (Dali::DaliException e) {
48593       {
48594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48595       };
48596     } catch (...) {
48597       {
48598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48599       };
48600     }
48601   }
48602
48603 }
48604
48605
48606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48607   int jresult ;
48608   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48609   Dali::Camera::ProjectionMode result;
48610
48611   arg1 = (Dali::CameraActor *)jarg1;
48612   {
48613     try {
48614       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48615     } catch (std::out_of_range& e) {
48616       {
48617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48618       };
48619     } catch (std::exception& e) {
48620       {
48621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48622       };
48623     } catch (Dali::DaliException e) {
48624       {
48625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48626       };
48627     } catch (...) {
48628       {
48629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48630       };
48631     }
48632   }
48633
48634   jresult = (int)result;
48635   return jresult;
48636 }
48637
48638
48639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48640   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48641   float arg2 ;
48642
48643   arg1 = (Dali::CameraActor *)jarg1;
48644   arg2 = (float)jarg2;
48645   {
48646     try {
48647       (arg1)->SetFieldOfView(arg2);
48648     } catch (std::out_of_range& e) {
48649       {
48650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48651       };
48652     } catch (std::exception& e) {
48653       {
48654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48655       };
48656     } catch (Dali::DaliException e) {
48657       {
48658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48659       };
48660     } catch (...) {
48661       {
48662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48663       };
48664     }
48665   }
48666
48667 }
48668
48669
48670 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48671   float jresult ;
48672   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48673   float result;
48674
48675   arg1 = (Dali::CameraActor *)jarg1;
48676   {
48677     try {
48678       result = (float)(arg1)->GetFieldOfView();
48679     } catch (std::out_of_range& e) {
48680       {
48681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48682       };
48683     } catch (std::exception& e) {
48684       {
48685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48686       };
48687     } catch (Dali::DaliException e) {
48688       {
48689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48690       };
48691     } catch (...) {
48692       {
48693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48694       };
48695     }
48696   }
48697
48698   jresult = result;
48699   return jresult;
48700 }
48701
48702
48703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48704   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48705   float arg2 ;
48706
48707   arg1 = (Dali::CameraActor *)jarg1;
48708   arg2 = (float)jarg2;
48709   {
48710     try {
48711       (arg1)->SetAspectRatio(arg2);
48712     } catch (std::out_of_range& e) {
48713       {
48714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48715       };
48716     } catch (std::exception& e) {
48717       {
48718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48719       };
48720     } catch (Dali::DaliException e) {
48721       {
48722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48723       };
48724     } catch (...) {
48725       {
48726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48727       };
48728     }
48729   }
48730
48731 }
48732
48733
48734 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48735   float jresult ;
48736   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48737   float result;
48738
48739   arg1 = (Dali::CameraActor *)jarg1;
48740   {
48741     try {
48742       result = (float)(arg1)->GetAspectRatio();
48743     } catch (std::out_of_range& e) {
48744       {
48745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48746       };
48747     } catch (std::exception& e) {
48748       {
48749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48750       };
48751     } catch (Dali::DaliException e) {
48752       {
48753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48754       };
48755     } catch (...) {
48756       {
48757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48758       };
48759     }
48760   }
48761
48762   jresult = result;
48763   return jresult;
48764 }
48765
48766
48767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48768   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48769   float arg2 ;
48770
48771   arg1 = (Dali::CameraActor *)jarg1;
48772   arg2 = (float)jarg2;
48773   {
48774     try {
48775       (arg1)->SetNearClippingPlane(arg2);
48776     } catch (std::out_of_range& e) {
48777       {
48778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48779       };
48780     } catch (std::exception& e) {
48781       {
48782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48783       };
48784     } catch (Dali::DaliException e) {
48785       {
48786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48787       };
48788     } catch (...) {
48789       {
48790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48791       };
48792     }
48793   }
48794
48795 }
48796
48797
48798 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48799   float jresult ;
48800   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48801   float result;
48802
48803   arg1 = (Dali::CameraActor *)jarg1;
48804   {
48805     try {
48806       result = (float)(arg1)->GetNearClippingPlane();
48807     } catch (std::out_of_range& e) {
48808       {
48809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48810       };
48811     } catch (std::exception& e) {
48812       {
48813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48814       };
48815     } catch (Dali::DaliException e) {
48816       {
48817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48818       };
48819     } catch (...) {
48820       {
48821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48822       };
48823     }
48824   }
48825
48826   jresult = result;
48827   return jresult;
48828 }
48829
48830
48831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48832   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48833   float arg2 ;
48834
48835   arg1 = (Dali::CameraActor *)jarg1;
48836   arg2 = (float)jarg2;
48837   {
48838     try {
48839       (arg1)->SetFarClippingPlane(arg2);
48840     } catch (std::out_of_range& e) {
48841       {
48842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48843       };
48844     } catch (std::exception& e) {
48845       {
48846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48847       };
48848     } catch (Dali::DaliException e) {
48849       {
48850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48851       };
48852     } catch (...) {
48853       {
48854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48855       };
48856     }
48857   }
48858
48859 }
48860
48861
48862 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48863   float jresult ;
48864   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48865   float result;
48866
48867   arg1 = (Dali::CameraActor *)jarg1;
48868   {
48869     try {
48870       result = (float)(arg1)->GetFarClippingPlane();
48871     } catch (std::out_of_range& e) {
48872       {
48873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48874       };
48875     } catch (std::exception& e) {
48876       {
48877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48878       };
48879     } catch (Dali::DaliException e) {
48880       {
48881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48882       };
48883     } catch (...) {
48884       {
48885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48886       };
48887     }
48888   }
48889
48890   jresult = result;
48891   return jresult;
48892 }
48893
48894
48895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48896   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48897   Dali::Vector3 *arg2 = 0 ;
48898
48899   arg1 = (Dali::CameraActor *)jarg1;
48900   arg2 = (Dali::Vector3 *)jarg2;
48901   if (!arg2) {
48902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48903     return ;
48904   }
48905   {
48906     try {
48907       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48908     } catch (std::out_of_range& e) {
48909       {
48910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48911       };
48912     } catch (std::exception& e) {
48913       {
48914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48915       };
48916     } catch (Dali::DaliException e) {
48917       {
48918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48919       };
48920     } catch (...) {
48921       {
48922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48923       };
48924     }
48925   }
48926
48927 }
48928
48929
48930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48931   void * jresult ;
48932   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48933   Dali::Vector3 result;
48934
48935   arg1 = (Dali::CameraActor *)jarg1;
48936   {
48937     try {
48938       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48939     } catch (std::out_of_range& e) {
48940       {
48941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48942       };
48943     } catch (std::exception& e) {
48944       {
48945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48946       };
48947     } catch (Dali::DaliException e) {
48948       {
48949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48950       };
48951     } catch (...) {
48952       {
48953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48954       };
48955     }
48956   }
48957
48958   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48959   return jresult;
48960 }
48961
48962
48963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48964   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48965   bool arg2 ;
48966
48967   arg1 = (Dali::CameraActor *)jarg1;
48968   arg2 = jarg2 ? true : false;
48969   {
48970     try {
48971       (arg1)->SetInvertYAxis(arg2);
48972     } catch (std::out_of_range& e) {
48973       {
48974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48975       };
48976     } catch (std::exception& e) {
48977       {
48978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48979       };
48980     } catch (Dali::DaliException e) {
48981       {
48982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48983       };
48984     } catch (...) {
48985       {
48986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48987       };
48988     }
48989   }
48990
48991 }
48992
48993
48994 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48995   unsigned int jresult ;
48996   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48997   bool result;
48998
48999   arg1 = (Dali::CameraActor *)jarg1;
49000   {
49001     try {
49002       result = (bool)(arg1)->GetInvertYAxis();
49003     } catch (std::out_of_range& e) {
49004       {
49005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49006       };
49007     } catch (std::exception& e) {
49008       {
49009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49010       };
49011     } catch (Dali::DaliException e) {
49012       {
49013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49014       };
49015     } catch (...) {
49016       {
49017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49018       };
49019     }
49020   }
49021
49022   jresult = result;
49023   return jresult;
49024 }
49025
49026
49027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
49028   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
49029   Dali::Size *arg2 = 0 ;
49030
49031   arg1 = (Dali::CameraActor *)jarg1;
49032   arg2 = (Dali::Size *)jarg2;
49033   if (!arg2) {
49034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
49035     return ;
49036   }
49037   {
49038     try {
49039       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
49040     } catch (std::out_of_range& e) {
49041       {
49042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49043       };
49044     } catch (std::exception& e) {
49045       {
49046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49047       };
49048     } catch (Dali::DaliException e) {
49049       {
49050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49051       };
49052     } catch (...) {
49053       {
49054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49055       };
49056     }
49057   }
49058
49059 }
49060
49061
49062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
49063   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
49064   Dali::Size *arg2 = 0 ;
49065
49066   arg1 = (Dali::CameraActor *)jarg1;
49067   arg2 = (Dali::Size *)jarg2;
49068   if (!arg2) {
49069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
49070     return ;
49071   }
49072   {
49073     try {
49074       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
49075     } catch (std::out_of_range& e) {
49076       {
49077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49078       };
49079     } catch (std::exception& e) {
49080       {
49081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49082       };
49083     } catch (Dali::DaliException e) {
49084       {
49085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49086       };
49087     } catch (...) {
49088       {
49089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49090       };
49091     }
49092   }
49093
49094 }
49095
49096
49097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
49098   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
49099   float arg2 ;
49100   float arg3 ;
49101   float arg4 ;
49102   float arg5 ;
49103   float arg6 ;
49104   float arg7 ;
49105
49106   arg1 = (Dali::CameraActor *)jarg1;
49107   arg2 = (float)jarg2;
49108   arg3 = (float)jarg3;
49109   arg4 = (float)jarg4;
49110   arg5 = (float)jarg5;
49111   arg6 = (float)jarg6;
49112   arg7 = (float)jarg7;
49113   {
49114     try {
49115       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
49116     } catch (std::out_of_range& e) {
49117       {
49118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49119       };
49120     } catch (std::exception& e) {
49121       {
49122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49123       };
49124     } catch (Dali::DaliException e) {
49125       {
49126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49127       };
49128     } catch (...) {
49129       {
49130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49131       };
49132     }
49133   }
49134
49135 }
49136
49137
49138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
49139   void * jresult ;
49140   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49141
49142   {
49143     try {
49144       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
49145     } catch (std::out_of_range& e) {
49146       {
49147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49148       };
49149     } catch (std::exception& e) {
49150       {
49151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49152       };
49153     } catch (Dali::DaliException e) {
49154       {
49155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49156       };
49157     } catch (...) {
49158       {
49159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49160       };
49161     }
49162   }
49163
49164   jresult = (void *)result;
49165   return jresult;
49166 }
49167
49168
49169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49170   void * jresult ;
49171   std::string arg1 ;
49172   Dali::Property::Value arg2 ;
49173   Dali::Property::Value *argp2 ;
49174   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49175
49176   if (!jarg1) {
49177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49178     return 0;
49179   }
49180   (&arg1)->assign(jarg1);
49181   argp2 = (Dali::Property::Value *)jarg2;
49182   if (!argp2) {
49183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49184     return 0;
49185   }
49186   arg2 = *argp2;
49187   {
49188     try {
49189       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49190     } catch (std::out_of_range& e) {
49191       {
49192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49193       };
49194     } catch (std::exception& e) {
49195       {
49196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49197       };
49198     } catch (Dali::DaliException e) {
49199       {
49200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49201       };
49202     } catch (...) {
49203       {
49204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49205       };
49206     }
49207   }
49208
49209   jresult = (void *)result;
49210   return jresult;
49211 }
49212
49213
49214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49215   void * jresult ;
49216   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49217   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49218
49219   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49220   if (!arg1) {
49221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49222     return 0;
49223   }
49224   {
49225     try {
49226       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);
49227     } catch (std::out_of_range& e) {
49228       {
49229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49230       };
49231     } catch (std::exception& e) {
49232       {
49233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49234       };
49235     } catch (Dali::DaliException e) {
49236       {
49237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49238       };
49239     } catch (...) {
49240       {
49241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49242       };
49243     }
49244   }
49245
49246   jresult = (void *)result;
49247   return jresult;
49248 }
49249
49250
49251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49252   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49253   std::string *arg2 = 0 ;
49254
49255   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49256   if (!jarg2) {
49257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49258     return ;
49259   }
49260   std::string arg2_str(jarg2);
49261   arg2 = &arg2_str;
49262   if (arg1) (arg1)->first = *arg2;
49263
49264   //argout typemap for const std::string&
49265
49266 }
49267
49268
49269 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49270   char * jresult ;
49271   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49272   std::string *result = 0 ;
49273
49274   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49275   result = (std::string *) & ((arg1)->first);
49276   jresult = SWIG_csharp_string_callback(result->c_str());
49277   return jresult;
49278 }
49279
49280
49281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49282   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49283   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49284
49285   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49286   arg2 = (Dali::Property::Value *)jarg2;
49287   if (arg1) (arg1)->second = *arg2;
49288 }
49289
49290
49291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49292   void * jresult ;
49293   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49294   Dali::Property::Value *result = 0 ;
49295
49296   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49297   result = (Dali::Property::Value *)& ((arg1)->second);
49298   jresult = (void *)result;
49299   return jresult;
49300 }
49301
49302
49303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49304   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49305
49306   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49307   {
49308     try {
49309       delete arg1;
49310     } catch (std::out_of_range& e) {
49311       {
49312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49313       };
49314     } catch (std::exception& e) {
49315       {
49316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49317       };
49318     } catch (Dali::DaliException e) {
49319       {
49320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49321       };
49322     } catch (...) {
49323       {
49324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49325       };
49326     }
49327   }
49328
49329 }
49330
49331
49332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49333   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49334
49335   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49336   {
49337     try {
49338       (arg1)->clear();
49339     } catch (std::out_of_range& e) {
49340       {
49341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49342       };
49343     } catch (std::exception& e) {
49344       {
49345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49346       };
49347     } catch (Dali::DaliException e) {
49348       {
49349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49350       };
49351     } catch (...) {
49352       {
49353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49354       };
49355     }
49356   }
49357
49358 }
49359
49360
49361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49362   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49363   Dali::TouchPoint *arg2 = 0 ;
49364
49365   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49366   arg2 = (Dali::TouchPoint *)jarg2;
49367   if (!arg2) {
49368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49369     return ;
49370   }
49371   {
49372     try {
49373       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49374     } catch (std::out_of_range& e) {
49375       {
49376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49377       };
49378     } catch (std::exception& e) {
49379       {
49380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49381       };
49382     } catch (Dali::DaliException e) {
49383       {
49384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49385       };
49386     } catch (...) {
49387       {
49388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49389       };
49390     }
49391   }
49392
49393 }
49394
49395
49396 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49397   unsigned long jresult ;
49398   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49399   std::vector< Dali::TouchPoint >::size_type result;
49400
49401   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49402   {
49403     try {
49404       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49405     } catch (std::out_of_range& e) {
49406       {
49407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49408       };
49409     } catch (std::exception& e) {
49410       {
49411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49412       };
49413     } catch (Dali::DaliException e) {
49414       {
49415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49416       };
49417     } catch (...) {
49418       {
49419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49420       };
49421     }
49422   }
49423
49424   jresult = (unsigned long)result;
49425   return jresult;
49426 }
49427
49428
49429 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49430   unsigned long jresult ;
49431   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49432   std::vector< Dali::TouchPoint >::size_type result;
49433
49434   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49435   {
49436     try {
49437       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49438     } catch (std::out_of_range& e) {
49439       {
49440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49441       };
49442     } catch (std::exception& e) {
49443       {
49444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49445       };
49446     } catch (Dali::DaliException e) {
49447       {
49448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49449       };
49450     } catch (...) {
49451       {
49452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49453       };
49454     }
49455   }
49456
49457   jresult = (unsigned long)result;
49458   return jresult;
49459 }
49460
49461
49462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49463   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49464   std::vector< Dali::TouchPoint >::size_type arg2 ;
49465
49466   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49467   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49468   {
49469     try {
49470       (arg1)->reserve(arg2);
49471     } catch (std::out_of_range& e) {
49472       {
49473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49474       };
49475     } catch (std::exception& e) {
49476       {
49477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49478       };
49479     } catch (Dali::DaliException e) {
49480       {
49481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49482       };
49483     } catch (...) {
49484       {
49485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49486       };
49487     }
49488   }
49489
49490 }
49491
49492
49493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49494   void * jresult ;
49495   std::vector< Dali::TouchPoint > *result = 0 ;
49496
49497   {
49498     try {
49499       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49500     } catch (std::out_of_range& e) {
49501       {
49502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49503       };
49504     } catch (std::exception& e) {
49505       {
49506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49507       };
49508     } catch (Dali::DaliException e) {
49509       {
49510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49511       };
49512     } catch (...) {
49513       {
49514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49515       };
49516     }
49517   }
49518
49519   jresult = (void *)result;
49520   return jresult;
49521 }
49522
49523
49524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49525   void * jresult ;
49526   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49527   std::vector< Dali::TouchPoint > *result = 0 ;
49528
49529   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49530   if (!arg1) {
49531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49532     return 0;
49533   }
49534   {
49535     try {
49536       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49537     } catch (std::out_of_range& e) {
49538       {
49539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49540       };
49541     } catch (std::exception& e) {
49542       {
49543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49544       };
49545     } catch (Dali::DaliException e) {
49546       {
49547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49548       };
49549     } catch (...) {
49550       {
49551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49552       };
49553     }
49554   }
49555
49556   jresult = (void *)result;
49557   return jresult;
49558 }
49559
49560
49561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49562   void * jresult ;
49563   int arg1 ;
49564   std::vector< Dali::TouchPoint > *result = 0 ;
49565
49566   arg1 = (int)jarg1;
49567   {
49568     try {
49569       try {
49570         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49571       }
49572       catch(std::out_of_range &_e) {
49573         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49574         return 0;
49575       }
49576
49577     } catch (std::out_of_range& e) {
49578       {
49579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49580       };
49581     } catch (std::exception& e) {
49582       {
49583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49584       };
49585     } catch (Dali::DaliException e) {
49586       {
49587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49588       };
49589     } catch (...) {
49590       {
49591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49592       };
49593     }
49594   }
49595
49596   jresult = (void *)result;
49597   return jresult;
49598 }
49599
49600
49601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49602   void * jresult ;
49603   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49604   int arg2 ;
49605   SwigValueWrapper< Dali::TouchPoint > result;
49606
49607   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49608   arg2 = (int)jarg2;
49609   {
49610     try {
49611       try {
49612         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49613       }
49614       catch(std::out_of_range &_e) {
49615         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49616         return 0;
49617       }
49618
49619     } catch (std::out_of_range& e) {
49620       {
49621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49622       };
49623     } catch (std::exception& e) {
49624       {
49625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49626       };
49627     } catch (Dali::DaliException e) {
49628       {
49629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49630       };
49631     } catch (...) {
49632       {
49633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49634       };
49635     }
49636   }
49637
49638   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49639   return jresult;
49640 }
49641
49642
49643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49644   void * jresult ;
49645   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49646   int arg2 ;
49647   Dali::TouchPoint *result = 0 ;
49648
49649   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49650   arg2 = (int)jarg2;
49651   {
49652     try {
49653       try {
49654         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49655       }
49656       catch(std::out_of_range &_e) {
49657         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49658         return 0;
49659       }
49660
49661     } catch (std::out_of_range& e) {
49662       {
49663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49664       };
49665     } catch (std::exception& e) {
49666       {
49667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49668       };
49669     } catch (Dali::DaliException e) {
49670       {
49671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49672       };
49673     } catch (...) {
49674       {
49675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49676       };
49677     }
49678   }
49679
49680   jresult = (void *)result;
49681   return jresult;
49682 }
49683
49684
49685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49686   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49687   int arg2 ;
49688   Dali::TouchPoint *arg3 = 0 ;
49689
49690   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49691   arg2 = (int)jarg2;
49692   arg3 = (Dali::TouchPoint *)jarg3;
49693   if (!arg3) {
49694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49695     return ;
49696   }
49697   {
49698     try {
49699       try {
49700         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49701       }
49702       catch(std::out_of_range &_e) {
49703         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49704         return ;
49705       }
49706
49707     } catch (std::out_of_range& e) {
49708       {
49709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49710       };
49711     } catch (std::exception& e) {
49712       {
49713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49714       };
49715     } catch (Dali::DaliException e) {
49716       {
49717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49718       };
49719     } catch (...) {
49720       {
49721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49722       };
49723     }
49724   }
49725
49726 }
49727
49728
49729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49730   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49731   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49732
49733   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49734   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49735   if (!arg2) {
49736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49737     return ;
49738   }
49739   {
49740     try {
49741       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49742     } catch (std::out_of_range& e) {
49743       {
49744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49745       };
49746     } catch (std::exception& e) {
49747       {
49748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49749       };
49750     } catch (Dali::DaliException e) {
49751       {
49752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49753       };
49754     } catch (...) {
49755       {
49756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49757       };
49758     }
49759   }
49760
49761 }
49762
49763
49764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49765   void * jresult ;
49766   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49767   int arg2 ;
49768   int arg3 ;
49769   std::vector< Dali::TouchPoint > *result = 0 ;
49770
49771   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49772   arg2 = (int)jarg2;
49773   arg3 = (int)jarg3;
49774   {
49775     try {
49776       try {
49777         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49778       }
49779       catch(std::out_of_range &_e) {
49780         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49781         return 0;
49782       }
49783       catch(std::invalid_argument &_e) {
49784         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49785         return 0;
49786       }
49787
49788     } catch (std::out_of_range& e) {
49789       {
49790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49791       };
49792     } catch (std::exception& e) {
49793       {
49794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49795       };
49796     } catch (Dali::DaliException e) {
49797       {
49798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49799       };
49800     } catch (...) {
49801       {
49802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49803       };
49804     }
49805   }
49806
49807   jresult = (void *)result;
49808   return jresult;
49809 }
49810
49811
49812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49813   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49814   int arg2 ;
49815   Dali::TouchPoint *arg3 = 0 ;
49816
49817   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49818   arg2 = (int)jarg2;
49819   arg3 = (Dali::TouchPoint *)jarg3;
49820   if (!arg3) {
49821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49822     return ;
49823   }
49824   {
49825     try {
49826       try {
49827         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49828       }
49829       catch(std::out_of_range &_e) {
49830         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49831         return ;
49832       }
49833
49834     } catch (std::out_of_range& e) {
49835       {
49836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49837       };
49838     } catch (std::exception& e) {
49839       {
49840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49841       };
49842     } catch (Dali::DaliException e) {
49843       {
49844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49845       };
49846     } catch (...) {
49847       {
49848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49849       };
49850     }
49851   }
49852
49853 }
49854
49855
49856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49857   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49858   int arg2 ;
49859   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49860
49861   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49862   arg2 = (int)jarg2;
49863   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49864   if (!arg3) {
49865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49866     return ;
49867   }
49868   {
49869     try {
49870       try {
49871         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49872       }
49873       catch(std::out_of_range &_e) {
49874         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49875         return ;
49876       }
49877
49878     } catch (std::out_of_range& e) {
49879       {
49880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49881       };
49882     } catch (std::exception& e) {
49883       {
49884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49885       };
49886     } catch (Dali::DaliException e) {
49887       {
49888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49889       };
49890     } catch (...) {
49891       {
49892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49893       };
49894     }
49895   }
49896
49897 }
49898
49899
49900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49901   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49902   int arg2 ;
49903
49904   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49905   arg2 = (int)jarg2;
49906   {
49907     try {
49908       try {
49909         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49910       }
49911       catch(std::out_of_range &_e) {
49912         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49913         return ;
49914       }
49915
49916     } catch (std::out_of_range& e) {
49917       {
49918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49919       };
49920     } catch (std::exception& e) {
49921       {
49922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49923       };
49924     } catch (Dali::DaliException e) {
49925       {
49926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49927       };
49928     } catch (...) {
49929       {
49930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49931       };
49932     }
49933   }
49934
49935 }
49936
49937
49938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49939   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49940   int arg2 ;
49941   int arg3 ;
49942
49943   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49944   arg2 = (int)jarg2;
49945   arg3 = (int)jarg3;
49946   {
49947     try {
49948       try {
49949         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49950       }
49951       catch(std::out_of_range &_e) {
49952         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49953         return ;
49954       }
49955       catch(std::invalid_argument &_e) {
49956         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49957         return ;
49958       }
49959
49960     } catch (std::out_of_range& e) {
49961       {
49962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49963       };
49964     } catch (std::exception& e) {
49965       {
49966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49967       };
49968     } catch (Dali::DaliException e) {
49969       {
49970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49971       };
49972     } catch (...) {
49973       {
49974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49975       };
49976     }
49977   }
49978
49979 }
49980
49981
49982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49983   void * jresult ;
49984   Dali::TouchPoint *arg1 = 0 ;
49985   int arg2 ;
49986   std::vector< Dali::TouchPoint > *result = 0 ;
49987
49988   arg1 = (Dali::TouchPoint *)jarg1;
49989   if (!arg1) {
49990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49991     return 0;
49992   }
49993   arg2 = (int)jarg2;
49994   {
49995     try {
49996       try {
49997         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49998       }
49999       catch(std::out_of_range &_e) {
50000         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
50001         return 0;
50002       }
50003
50004     } catch (std::out_of_range& e) {
50005       {
50006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50007       };
50008     } catch (std::exception& e) {
50009       {
50010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50011       };
50012     } catch (Dali::DaliException e) {
50013       {
50014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50015       };
50016     } catch (...) {
50017       {
50018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50019       };
50020     }
50021   }
50022
50023   jresult = (void *)result;
50024   return jresult;
50025 }
50026
50027
50028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
50029   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50030
50031   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50032   {
50033     try {
50034       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
50035     } catch (std::out_of_range& e) {
50036       {
50037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50038       };
50039     } catch (std::exception& e) {
50040       {
50041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50042       };
50043     } catch (Dali::DaliException e) {
50044       {
50045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50046       };
50047     } catch (...) {
50048       {
50049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50050       };
50051     }
50052   }
50053
50054 }
50055
50056
50057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
50058   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50059   int arg2 ;
50060   int arg3 ;
50061
50062   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50063   arg2 = (int)jarg2;
50064   arg3 = (int)jarg3;
50065   {
50066     try {
50067       try {
50068         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
50069       }
50070       catch(std::out_of_range &_e) {
50071         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
50072         return ;
50073       }
50074       catch(std::invalid_argument &_e) {
50075         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
50076         return ;
50077       }
50078
50079     } catch (std::out_of_range& e) {
50080       {
50081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50082       };
50083     } catch (std::exception& e) {
50084       {
50085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50086       };
50087     } catch (Dali::DaliException e) {
50088       {
50089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50090       };
50091     } catch (...) {
50092       {
50093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50094       };
50095     }
50096   }
50097
50098 }
50099
50100
50101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
50102   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50103   int arg2 ;
50104   std::vector< Dali::TouchPoint > *arg3 = 0 ;
50105
50106   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50107   arg2 = (int)jarg2;
50108   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
50109   if (!arg3) {
50110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
50111     return ;
50112   }
50113   {
50114     try {
50115       try {
50116         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
50117       }
50118       catch(std::out_of_range &_e) {
50119         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
50120         return ;
50121       }
50122
50123     } catch (std::out_of_range& e) {
50124       {
50125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50126       };
50127     } catch (std::exception& e) {
50128       {
50129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50130       };
50131     } catch (Dali::DaliException e) {
50132       {
50133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50134       };
50135     } catch (...) {
50136       {
50137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50138       };
50139     }
50140   }
50141
50142 }
50143
50144
50145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
50146   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50147
50148   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50149   {
50150     try {
50151       delete arg1;
50152     } catch (std::out_of_range& e) {
50153       {
50154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50155       };
50156     } catch (std::exception& e) {
50157       {
50158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50159       };
50160     } catch (Dali::DaliException e) {
50161       {
50162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50163       };
50164     } catch (...) {
50165       {
50166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50167       };
50168     }
50169   }
50170
50171 }
50172
50173
50174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50175   void * jresult ;
50176   Dali::Rect< int > *result = 0 ;
50177
50178   {
50179     try {
50180       result = (Dali::Rect< int > *)new Dali::Rect< int >();
50181     } catch (std::out_of_range& e) {
50182       {
50183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50184       };
50185     } catch (std::exception& e) {
50186       {
50187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50188       };
50189     } catch (Dali::DaliException e) {
50190       {
50191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50192       };
50193     } catch (...) {
50194       {
50195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50196       };
50197     }
50198   }
50199
50200   jresult = (void *)result;
50201   return jresult;
50202 }
50203
50204
50205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50206   void * jresult ;
50207   int arg1 ;
50208   int arg2 ;
50209   int arg3 ;
50210   int arg4 ;
50211   Dali::Rect< int > *result = 0 ;
50212
50213   arg1 = (int)jarg1;
50214   arg2 = (int)jarg2;
50215   arg3 = (int)jarg3;
50216   arg4 = (int)jarg4;
50217   {
50218     try {
50219       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50220     } catch (std::out_of_range& e) {
50221       {
50222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50223       };
50224     } catch (std::exception& e) {
50225       {
50226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50227       };
50228     } catch (Dali::DaliException e) {
50229       {
50230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50231       };
50232     } catch (...) {
50233       {
50234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50235       };
50236     }
50237   }
50238
50239   jresult = (void *)result;
50240   return jresult;
50241 }
50242
50243
50244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50245   void * jresult ;
50246   Dali::Rect< int > *arg1 = 0 ;
50247   Dali::Rect< int > *result = 0 ;
50248
50249   arg1 = (Dali::Rect< int > *)jarg1;
50250   if (!arg1) {
50251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50252     return 0;
50253   }
50254   {
50255     try {
50256       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
50257     } catch (std::out_of_range& e) {
50258       {
50259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50260       };
50261     } catch (std::exception& e) {
50262       {
50263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50264       };
50265     } catch (Dali::DaliException e) {
50266       {
50267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50268       };
50269     } catch (...) {
50270       {
50271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50272       };
50273     }
50274   }
50275
50276   jresult = (void *)result;
50277   return jresult;
50278 }
50279
50280
50281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
50282   void * jresult ;
50283   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50284   Dali::Rect< int > *arg2 = 0 ;
50285   Dali::Rect< int > *result = 0 ;
50286
50287   arg1 = (Dali::Rect< int > *)jarg1;
50288   arg2 = (Dali::Rect< int > *)jarg2;
50289   if (!arg2) {
50290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50291     return 0;
50292   }
50293   {
50294     try {
50295       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50296     } catch (std::out_of_range& e) {
50297       {
50298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50299       };
50300     } catch (std::exception& e) {
50301       {
50302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50303       };
50304     } catch (Dali::DaliException e) {
50305       {
50306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50307       };
50308     } catch (...) {
50309       {
50310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50311       };
50312     }
50313   }
50314
50315   jresult = (void *)result;
50316   return jresult;
50317 }
50318
50319
50320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50321   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50322   int arg2 ;
50323   int arg3 ;
50324   int arg4 ;
50325   int arg5 ;
50326
50327   arg1 = (Dali::Rect< int > *)jarg1;
50328   arg2 = (int)jarg2;
50329   arg3 = (int)jarg3;
50330   arg4 = (int)jarg4;
50331   arg5 = (int)jarg5;
50332   {
50333     try {
50334       (arg1)->Set(arg2,arg3,arg4,arg5);
50335     } catch (std::out_of_range& e) {
50336       {
50337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50338       };
50339     } catch (std::exception& e) {
50340       {
50341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50342       };
50343     } catch (Dali::DaliException e) {
50344       {
50345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50346       };
50347     } catch (...) {
50348       {
50349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50350       };
50351     }
50352   }
50353
50354 }
50355
50356
50357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50358   unsigned int jresult ;
50359   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50360   bool result;
50361
50362   arg1 = (Dali::Rect< int > *)jarg1;
50363   {
50364     try {
50365       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50366     } catch (std::out_of_range& e) {
50367       {
50368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50369       };
50370     } catch (std::exception& e) {
50371       {
50372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50373       };
50374     } catch (Dali::DaliException e) {
50375       {
50376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50377       };
50378     } catch (...) {
50379       {
50380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50381       };
50382     }
50383   }
50384
50385   jresult = result;
50386   return jresult;
50387 }
50388
50389
50390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50391   int jresult ;
50392   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50393   int result;
50394
50395   arg1 = (Dali::Rect< int > *)jarg1;
50396   {
50397     try {
50398       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50399     } catch (std::out_of_range& e) {
50400       {
50401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50402       };
50403     } catch (std::exception& e) {
50404       {
50405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50406       };
50407     } catch (Dali::DaliException e) {
50408       {
50409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50410       };
50411     } catch (...) {
50412       {
50413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50414       };
50415     }
50416   }
50417
50418   jresult = result;
50419   return jresult;
50420 }
50421
50422
50423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50424   int jresult ;
50425   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50426   int result;
50427
50428   arg1 = (Dali::Rect< int > *)jarg1;
50429   {
50430     try {
50431       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50432     } catch (std::out_of_range& e) {
50433       {
50434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50435       };
50436     } catch (std::exception& e) {
50437       {
50438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50439       };
50440     } catch (Dali::DaliException e) {
50441       {
50442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50443       };
50444     } catch (...) {
50445       {
50446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50447       };
50448     }
50449   }
50450
50451   jresult = result;
50452   return jresult;
50453 }
50454
50455
50456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50457   int jresult ;
50458   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50459   int result;
50460
50461   arg1 = (Dali::Rect< int > *)jarg1;
50462   {
50463     try {
50464       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50465     } catch (std::out_of_range& e) {
50466       {
50467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50468       };
50469     } catch (std::exception& e) {
50470       {
50471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50472       };
50473     } catch (Dali::DaliException e) {
50474       {
50475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50476       };
50477     } catch (...) {
50478       {
50479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50480       };
50481     }
50482   }
50483
50484   jresult = result;
50485   return jresult;
50486 }
50487
50488
50489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50490   int jresult ;
50491   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50492   int result;
50493
50494   arg1 = (Dali::Rect< int > *)jarg1;
50495   {
50496     try {
50497       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50498     } catch (std::out_of_range& e) {
50499       {
50500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50501       };
50502     } catch (std::exception& e) {
50503       {
50504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50505       };
50506     } catch (Dali::DaliException e) {
50507       {
50508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50509       };
50510     } catch (...) {
50511       {
50512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50513       };
50514     }
50515   }
50516
50517   jresult = result;
50518   return jresult;
50519 }
50520
50521
50522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50523   int jresult ;
50524   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50525   int result;
50526
50527   arg1 = (Dali::Rect< int > *)jarg1;
50528   {
50529     try {
50530       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50531     } catch (std::out_of_range& e) {
50532       {
50533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50534       };
50535     } catch (std::exception& e) {
50536       {
50537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50538       };
50539     } catch (Dali::DaliException e) {
50540       {
50541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50542       };
50543     } catch (...) {
50544       {
50545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50546       };
50547     }
50548   }
50549
50550   jresult = result;
50551   return jresult;
50552 }
50553
50554
50555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50556   unsigned int jresult ;
50557   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50558   Dali::Rect< int > *arg2 = 0 ;
50559   bool result;
50560
50561   arg1 = (Dali::Rect< int > *)jarg1;
50562   arg2 = (Dali::Rect< int > *)jarg2;
50563   if (!arg2) {
50564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50565     return 0;
50566   }
50567   {
50568     try {
50569       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50570     } catch (std::out_of_range& e) {
50571       {
50572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50573       };
50574     } catch (std::exception& e) {
50575       {
50576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50577       };
50578     } catch (Dali::DaliException e) {
50579       {
50580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50581       };
50582     } catch (...) {
50583       {
50584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50585       };
50586     }
50587   }
50588
50589   jresult = result;
50590   return jresult;
50591 }
50592
50593
50594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50595   unsigned int jresult ;
50596   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50597   Dali::Rect< int > *arg2 = 0 ;
50598   bool result;
50599
50600   arg1 = (Dali::Rect< int > *)jarg1;
50601   arg2 = (Dali::Rect< int > *)jarg2;
50602   if (!arg2) {
50603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50604     return 0;
50605   }
50606   {
50607     try {
50608       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50609     } catch (std::out_of_range& e) {
50610       {
50611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50612       };
50613     } catch (std::exception& e) {
50614       {
50615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50616       };
50617     } catch (Dali::DaliException e) {
50618       {
50619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50620       };
50621     } catch (...) {
50622       {
50623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50624       };
50625     }
50626   }
50627
50628   jresult = result;
50629   return jresult;
50630 }
50631
50632
50633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50634   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50635   int arg2 ;
50636
50637   arg1 = (Dali::Rect< int > *)jarg1;
50638   arg2 = (int)jarg2;
50639   if (arg1) (arg1)->x = arg2;
50640 }
50641
50642
50643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50644   int jresult ;
50645   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50646   int result;
50647
50648   arg1 = (Dali::Rect< int > *)jarg1;
50649   result = (int) ((arg1)->x);
50650   jresult = result;
50651   return jresult;
50652 }
50653
50654
50655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50656   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50657   int arg2 ;
50658
50659   arg1 = (Dali::Rect< int > *)jarg1;
50660   arg2 = (int)jarg2;
50661   if (arg1) (arg1)->left = arg2;
50662 }
50663
50664
50665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50666   int jresult ;
50667   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50668   int result;
50669
50670   arg1 = (Dali::Rect< int > *)jarg1;
50671   result = (int) ((arg1)->left);
50672   jresult = result;
50673   return jresult;
50674 }
50675
50676
50677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50678   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50679   int arg2 ;
50680
50681   arg1 = (Dali::Rect< int > *)jarg1;
50682   arg2 = (int)jarg2;
50683   if (arg1) (arg1)->y = arg2;
50684 }
50685
50686
50687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50688   int jresult ;
50689   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50690   int result;
50691
50692   arg1 = (Dali::Rect< int > *)jarg1;
50693   result = (int) ((arg1)->y);
50694   jresult = result;
50695   return jresult;
50696 }
50697
50698
50699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50700   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50701   int arg2 ;
50702
50703   arg1 = (Dali::Rect< int > *)jarg1;
50704   arg2 = (int)jarg2;
50705   if (arg1) (arg1)->right = arg2;
50706 }
50707
50708
50709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50710   int jresult ;
50711   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50712   int result;
50713
50714   arg1 = (Dali::Rect< int > *)jarg1;
50715   result = (int) ((arg1)->right);
50716   jresult = result;
50717   return jresult;
50718 }
50719
50720
50721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50722   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50723   int arg2 ;
50724
50725   arg1 = (Dali::Rect< int > *)jarg1;
50726   arg2 = (int)jarg2;
50727   if (arg1) (arg1)->width = arg2;
50728 }
50729
50730
50731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50732   int jresult ;
50733   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50734   int result;
50735
50736   arg1 = (Dali::Rect< int > *)jarg1;
50737   result = (int) ((arg1)->width);
50738   jresult = result;
50739   return jresult;
50740 }
50741
50742
50743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50744   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50745   int arg2 ;
50746
50747   arg1 = (Dali::Rect< int > *)jarg1;
50748   arg2 = (int)jarg2;
50749   if (arg1) (arg1)->bottom = arg2;
50750 }
50751
50752
50753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50754   int jresult ;
50755   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50756   int result;
50757
50758   arg1 = (Dali::Rect< int > *)jarg1;
50759   result = (int) ((arg1)->bottom);
50760   jresult = result;
50761   return jresult;
50762 }
50763
50764
50765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50766   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50767   int arg2 ;
50768
50769   arg1 = (Dali::Rect< int > *)jarg1;
50770   arg2 = (int)jarg2;
50771   if (arg1) (arg1)->height = arg2;
50772 }
50773
50774
50775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50776   int jresult ;
50777   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50778   int result;
50779
50780   arg1 = (Dali::Rect< int > *)jarg1;
50781   result = (int) ((arg1)->height);
50782   jresult = result;
50783   return jresult;
50784 }
50785
50786
50787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50788   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50789   int arg2 ;
50790
50791   arg1 = (Dali::Rect< int > *)jarg1;
50792   arg2 = (int)jarg2;
50793   if (arg1) (arg1)->top = arg2;
50794 }
50795
50796
50797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50798   int jresult ;
50799   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50800   int result;
50801
50802   arg1 = (Dali::Rect< int > *)jarg1;
50803   result = (int) ((arg1)->top);
50804   jresult = result;
50805   return jresult;
50806 }
50807
50808
50809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50810   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50811
50812   arg1 = (Dali::Rect< int > *)jarg1;
50813   {
50814     try {
50815       delete arg1;
50816     } catch (std::out_of_range& e) {
50817       {
50818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50819       };
50820     } catch (std::exception& e) {
50821       {
50822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50823       };
50824     } catch (Dali::DaliException e) {
50825       {
50826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50827       };
50828     } catch (...) {
50829       {
50830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50831       };
50832     }
50833   }
50834
50835 }
50836
50837
50838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50839   void * jresult ;
50840   Dali::Rect< float > *result = 0 ;
50841
50842   {
50843     try {
50844       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50845     } catch (std::out_of_range& e) {
50846       {
50847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50848       };
50849     } catch (std::exception& e) {
50850       {
50851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50852       };
50853     } catch (Dali::DaliException e) {
50854       {
50855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50856       };
50857     } catch (...) {
50858       {
50859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50860       };
50861     }
50862   }
50863
50864   jresult = (void *)result;
50865   return jresult;
50866 }
50867
50868
50869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50870   void * jresult ;
50871   float arg1 ;
50872   float arg2 ;
50873   float arg3 ;
50874   float arg4 ;
50875   Dali::Rect< float > *result = 0 ;
50876
50877   arg1 = (float)jarg1;
50878   arg2 = (float)jarg2;
50879   arg3 = (float)jarg4;
50880   arg4 = (float)jarg3;
50881   {
50882     try {
50883       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50884     } catch (std::out_of_range& e) {
50885       {
50886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50887       };
50888     } catch (std::exception& e) {
50889       {
50890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50891       };
50892     } catch (Dali::DaliException e) {
50893       {
50894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50895       };
50896     } catch (...) {
50897       {
50898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50899       };
50900     }
50901   }
50902
50903   jresult = (void *)result;
50904   return jresult;
50905 }
50906
50907
50908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50909   void * jresult ;
50910   Dali::Rect< float > *arg1 = 0 ;
50911   Dali::Rect< float > *result = 0 ;
50912
50913   arg1 = (Dali::Rect< float > *)jarg1;
50914   if (!arg1) {
50915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50916     return 0;
50917   }
50918   {
50919     try {
50920       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50921     } catch (std::out_of_range& e) {
50922       {
50923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50924       };
50925     } catch (std::exception& e) {
50926       {
50927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50928       };
50929     } catch (Dali::DaliException e) {
50930       {
50931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50932       };
50933     } catch (...) {
50934       {
50935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50936       };
50937     }
50938   }
50939
50940   jresult = (void *)result;
50941   return jresult;
50942 }
50943
50944
50945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50946   void * jresult ;
50947   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50948   Dali::Rect< float > *arg2 = 0 ;
50949   Dali::Rect< float > *result = 0 ;
50950
50951   arg1 = (Dali::Rect< float > *)jarg1;
50952   arg2 = (Dali::Rect< float > *)jarg2;
50953   if (!arg2) {
50954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50955     return 0;
50956   }
50957   {
50958     try {
50959       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50960     } catch (std::out_of_range& e) {
50961       {
50962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50963       };
50964     } catch (std::exception& e) {
50965       {
50966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50967       };
50968     } catch (Dali::DaliException e) {
50969       {
50970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50971       };
50972     } catch (...) {
50973       {
50974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50975       };
50976     }
50977   }
50978
50979   jresult = (void *)result;
50980   return jresult;
50981 }
50982
50983
50984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50985   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50986   float arg2 ;
50987   float arg3 ;
50988   float arg4 ;
50989   float arg5 ;
50990
50991   arg1 = (Dali::Rect< float > *)jarg1;
50992   arg2 = (float)jarg2;
50993   arg3 = (float)jarg3;
50994   arg4 = (float)jarg5;
50995   arg5 = (float)jarg4;
50996   {
50997     try {
50998       (arg1)->Set(arg2,arg3,arg4,arg5);
50999     } catch (std::out_of_range& e) {
51000       {
51001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51002       };
51003     } catch (std::exception& e) {
51004       {
51005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51006       };
51007     } catch (Dali::DaliException e) {
51008       {
51009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51010       };
51011     } catch (...) {
51012       {
51013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51014       };
51015     }
51016   }
51017
51018 }
51019
51020
51021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
51022   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51023   float arg2 ;
51024
51025   arg1 = (Dali::Rect< float > *)jarg1;
51026   arg2 = (float)jarg2;
51027   if (arg1) (arg1)->left = arg2;
51028 }
51029
51030
51031 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
51032   float jresult ;
51033   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51034   float result;
51035
51036   arg1 = (Dali::Rect< float > *)jarg1;
51037   result = (float) ((arg1)->left);
51038   jresult = result;
51039   return jresult;
51040 }
51041
51042
51043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
51044   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51045   float arg2 ;
51046
51047   arg1 = (Dali::Rect< float > *)jarg1;
51048   arg2 = (float)jarg2;
51049   if (arg1) (arg1)->left = arg2;
51050 }
51051
51052
51053 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
51054   float jresult ;
51055   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51056   float result;
51057
51058   arg1 = (Dali::Rect< float > *)jarg1;
51059   result = (float) ((arg1)->left);
51060   jresult = result;
51061   return jresult;
51062 }
51063
51064
51065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
51066   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51067   float arg2 ;
51068
51069   arg1 = (Dali::Rect< float > *)jarg1;
51070   arg2 = (float)jarg2;
51071   if (arg1) (arg1)->right = arg2;
51072 }
51073
51074
51075 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
51076   float jresult ;
51077   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51078   float result;
51079
51080   arg1 = (Dali::Rect< float > *)jarg1;
51081   result = (float) ((arg1)->right);
51082   jresult = result;
51083   return jresult;
51084 }
51085
51086
51087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
51088   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51089   float arg2 ;
51090
51091   arg1 = (Dali::Rect< float > *)jarg1;
51092   arg2 = (float)jarg2;
51093   if (arg1) (arg1)->right = arg2;
51094 }
51095
51096
51097 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
51098   float jresult ;
51099   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51100   float result;
51101
51102   arg1 = (Dali::Rect< float > *)jarg1;
51103   result = (float) ((arg1)->right);
51104   jresult = result;
51105   return jresult;
51106 }
51107
51108
51109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
51110   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51111   float arg2 ;
51112
51113   arg1 = (Dali::Rect< float > *)jarg1;
51114   arg2 = (float)jarg2;
51115   if (arg1) (arg1)->bottom = arg2;
51116 }
51117
51118
51119 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
51120   float jresult ;
51121   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51122   float result;
51123
51124   arg1 = (Dali::Rect< float > *)jarg1;
51125   result = (float) ((arg1)->bottom);
51126   jresult = result;
51127   return jresult;
51128 }
51129
51130
51131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
51132   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51133   float arg2 ;
51134
51135   arg1 = (Dali::Rect< float > *)jarg1;
51136   arg2 = (float)jarg2;
51137   if (arg1) (arg1)->top = arg2;
51138 }
51139
51140
51141 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
51142   float jresult ;
51143   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51144   float result;
51145
51146   arg1 = (Dali::Rect< float > *)jarg1;
51147   result = (float) ((arg1)->top);
51148   jresult = result;
51149   return jresult;
51150 }
51151
51152
51153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
51154   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51155
51156   arg1 = (Dali::Rect< float > *)jarg1;
51157   {
51158     try {
51159       delete arg1;
51160     } catch (std::out_of_range& e) {
51161       {
51162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51163       };
51164     } catch (std::exception& e) {
51165       {
51166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51167       };
51168     } catch (Dali::DaliException e) {
51169       {
51170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51171       };
51172     } catch (...) {
51173       {
51174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51175       };
51176     }
51177   }
51178
51179 }
51180
51181
51182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51183   int jresult ;
51184   int result;
51185
51186   result = (int)Dali::Vector< int >::BaseType;
51187   jresult = (int)result;
51188   return jresult;
51189 }
51190
51191
51192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51193   void * jresult ;
51194   Dali::Vector< int > *result = 0 ;
51195
51196   {
51197     try {
51198       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51199     } catch (std::out_of_range& e) {
51200       {
51201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51202       };
51203     } catch (std::exception& e) {
51204       {
51205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51206       };
51207     } catch (Dali::DaliException e) {
51208       {
51209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51210       };
51211     } catch (...) {
51212       {
51213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51214       };
51215     }
51216   }
51217
51218   jresult = (void *)result;
51219   return jresult;
51220 }
51221
51222
51223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51224   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51225
51226   arg1 = (Dali::Vector< int > *)jarg1;
51227   {
51228     try {
51229       delete arg1;
51230     } catch (std::out_of_range& e) {
51231       {
51232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51233       };
51234     } catch (std::exception& e) {
51235       {
51236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51237       };
51238     } catch (Dali::DaliException e) {
51239       {
51240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51241       };
51242     } catch (...) {
51243       {
51244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51245       };
51246     }
51247   }
51248
51249 }
51250
51251
51252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51253   void * jresult ;
51254   Dali::Vector< int > *arg1 = 0 ;
51255   Dali::Vector< int > *result = 0 ;
51256
51257   arg1 = (Dali::Vector< int > *)jarg1;
51258   if (!arg1) {
51259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51260     return 0;
51261   }
51262   {
51263     try {
51264       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51265     } catch (std::out_of_range& e) {
51266       {
51267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51268       };
51269     } catch (std::exception& e) {
51270       {
51271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51272       };
51273     } catch (Dali::DaliException e) {
51274       {
51275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51276       };
51277     } catch (...) {
51278       {
51279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51280       };
51281     }
51282   }
51283
51284   jresult = (void *)result;
51285   return jresult;
51286 }
51287
51288
51289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51290   void * jresult ;
51291   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51292   Dali::Vector< int > *arg2 = 0 ;
51293   Dali::Vector< int > *result = 0 ;
51294
51295   arg1 = (Dali::Vector< int > *)jarg1;
51296   arg2 = (Dali::Vector< int > *)jarg2;
51297   if (!arg2) {
51298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51299     return 0;
51300   }
51301   {
51302     try {
51303       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51304     } catch (std::out_of_range& e) {
51305       {
51306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51307       };
51308     } catch (std::exception& e) {
51309       {
51310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51311       };
51312     } catch (Dali::DaliException e) {
51313       {
51314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51315       };
51316     } catch (...) {
51317       {
51318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51319       };
51320     }
51321   }
51322
51323   jresult = (void *)result;
51324   return jresult;
51325 }
51326
51327
51328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51329   void * jresult ;
51330   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51331   Dali::Vector< int >::Iterator result;
51332
51333   arg1 = (Dali::Vector< int > *)jarg1;
51334   {
51335     try {
51336       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51337     } catch (std::out_of_range& e) {
51338       {
51339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51340       };
51341     } catch (std::exception& e) {
51342       {
51343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51344       };
51345     } catch (Dali::DaliException e) {
51346       {
51347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51348       };
51349     } catch (...) {
51350       {
51351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51352       };
51353     }
51354   }
51355
51356   jresult = (void *)result;
51357   return jresult;
51358 }
51359
51360
51361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51362   void * jresult ;
51363   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51364   Dali::Vector< int >::Iterator result;
51365
51366   arg1 = (Dali::Vector< int > *)jarg1;
51367   {
51368     try {
51369       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51370     } catch (std::out_of_range& e) {
51371       {
51372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51373       };
51374     } catch (std::exception& e) {
51375       {
51376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51377       };
51378     } catch (Dali::DaliException e) {
51379       {
51380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51381       };
51382     } catch (...) {
51383       {
51384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51385       };
51386     }
51387   }
51388
51389   jresult = (void *)result;
51390   return jresult;
51391 }
51392
51393
51394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51395   void * jresult ;
51396   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51397   Dali::Vector< int >::SizeType arg2 ;
51398   Dali::Vector< int >::ItemType *result = 0 ;
51399
51400   arg1 = (Dali::Vector< int > *)jarg1;
51401   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51402   {
51403     try {
51404       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51405     } catch (std::out_of_range& e) {
51406       {
51407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51408       };
51409     } catch (std::exception& e) {
51410       {
51411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51412       };
51413     } catch (Dali::DaliException e) {
51414       {
51415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51416       };
51417     } catch (...) {
51418       {
51419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51420       };
51421     }
51422   }
51423
51424   jresult = (void *)result;
51425   return jresult;
51426 }
51427
51428
51429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51430   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51431   Dali::Vector< int >::ItemType *arg2 = 0 ;
51432   Dali::Vector< int >::ItemType temp2 ;
51433
51434   arg1 = (Dali::Vector< int > *)jarg1;
51435   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51436   arg2 = &temp2;
51437   {
51438     try {
51439       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51440     } catch (std::out_of_range& e) {
51441       {
51442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51443       };
51444     } catch (std::exception& e) {
51445       {
51446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51447       };
51448     } catch (Dali::DaliException e) {
51449       {
51450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51451       };
51452     } catch (...) {
51453       {
51454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51455       };
51456     }
51457   }
51458
51459 }
51460
51461
51462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51463   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51464   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51465   Dali::Vector< int >::ItemType *arg3 = 0 ;
51466   Dali::Vector< int >::ItemType temp3 ;
51467
51468   arg1 = (Dali::Vector< int > *)jarg1;
51469   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51470   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51471   arg3 = &temp3;
51472   {
51473     try {
51474       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51475     } catch (std::out_of_range& e) {
51476       {
51477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51478       };
51479     } catch (std::exception& e) {
51480       {
51481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51482       };
51483     } catch (Dali::DaliException e) {
51484       {
51485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51486       };
51487     } catch (...) {
51488       {
51489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51490       };
51491     }
51492   }
51493
51494 }
51495
51496
51497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51498   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51499   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51500   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51501   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51502
51503   arg1 = (Dali::Vector< int > *)jarg1;
51504   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51505   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51506   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51507   {
51508     try {
51509       (arg1)->Insert(arg2,arg3,arg4);
51510     } catch (std::out_of_range& e) {
51511       {
51512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51513       };
51514     } catch (std::exception& e) {
51515       {
51516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51517       };
51518     } catch (Dali::DaliException e) {
51519       {
51520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51521       };
51522     } catch (...) {
51523       {
51524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51525       };
51526     }
51527   }
51528
51529 }
51530
51531
51532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51533   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51534   Dali::Vector< int >::SizeType arg2 ;
51535
51536   arg1 = (Dali::Vector< int > *)jarg1;
51537   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51538   {
51539     try {
51540       (arg1)->Reserve(arg2);
51541     } catch (std::out_of_range& e) {
51542       {
51543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51544       };
51545     } catch (std::exception& e) {
51546       {
51547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51548       };
51549     } catch (Dali::DaliException e) {
51550       {
51551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51552       };
51553     } catch (...) {
51554       {
51555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51556       };
51557     }
51558   }
51559
51560 }
51561
51562
51563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51564   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51565   Dali::Vector< int >::SizeType arg2 ;
51566
51567   arg1 = (Dali::Vector< int > *)jarg1;
51568   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51569   {
51570     try {
51571       (arg1)->Resize(arg2);
51572     } catch (std::out_of_range& e) {
51573       {
51574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51575       };
51576     } catch (std::exception& e) {
51577       {
51578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51579       };
51580     } catch (Dali::DaliException e) {
51581       {
51582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51583       };
51584     } catch (...) {
51585       {
51586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51587       };
51588     }
51589   }
51590
51591 }
51592
51593
51594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51595   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51596   Dali::Vector< int >::SizeType arg2 ;
51597   Dali::Vector< int >::ItemType *arg3 = 0 ;
51598   Dali::Vector< int >::ItemType temp3 ;
51599
51600   arg1 = (Dali::Vector< int > *)jarg1;
51601   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51602   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51603   arg3 = &temp3;
51604   {
51605     try {
51606       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51607     } catch (std::out_of_range& e) {
51608       {
51609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51610       };
51611     } catch (std::exception& e) {
51612       {
51613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51614       };
51615     } catch (Dali::DaliException e) {
51616       {
51617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51618       };
51619     } catch (...) {
51620       {
51621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51622       };
51623     }
51624   }
51625
51626 }
51627
51628
51629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51630   void * jresult ;
51631   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51632   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51633   Dali::Vector< int >::Iterator result;
51634
51635   arg1 = (Dali::Vector< int > *)jarg1;
51636   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51637   {
51638     try {
51639       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51640     } catch (std::out_of_range& e) {
51641       {
51642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51643       };
51644     } catch (std::exception& e) {
51645       {
51646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51647       };
51648     } catch (Dali::DaliException e) {
51649       {
51650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51651       };
51652     } catch (...) {
51653       {
51654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51655       };
51656     }
51657   }
51658
51659   jresult = (void *)result;
51660   return jresult;
51661 }
51662
51663
51664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51665   void * jresult ;
51666   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51667   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51668   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51669   Dali::Vector< int >::Iterator result;
51670
51671   arg1 = (Dali::Vector< int > *)jarg1;
51672   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51673   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51674   {
51675     try {
51676       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51677     } catch (std::out_of_range& e) {
51678       {
51679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51680       };
51681     } catch (std::exception& e) {
51682       {
51683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51684       };
51685     } catch (Dali::DaliException e) {
51686       {
51687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51688       };
51689     } catch (...) {
51690       {
51691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51692       };
51693     }
51694   }
51695
51696   jresult = (void *)result;
51697   return jresult;
51698 }
51699
51700
51701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51702   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51703   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51704
51705   arg1 = (Dali::Vector< int > *)jarg1;
51706   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51707   {
51708     try {
51709       (arg1)->Remove(arg2);
51710     } catch (std::out_of_range& e) {
51711       {
51712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51713       };
51714     } catch (std::exception& e) {
51715       {
51716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51717       };
51718     } catch (Dali::DaliException e) {
51719       {
51720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51721       };
51722     } catch (...) {
51723       {
51724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51725       };
51726     }
51727   }
51728
51729 }
51730
51731
51732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51733   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51734   Dali::Vector< int > *arg2 = 0 ;
51735
51736   arg1 = (Dali::Vector< int > *)jarg1;
51737   arg2 = (Dali::Vector< int > *)jarg2;
51738   if (!arg2) {
51739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51740     return ;
51741   }
51742   {
51743     try {
51744       (arg1)->Swap(*arg2);
51745     } catch (std::out_of_range& e) {
51746       {
51747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51748       };
51749     } catch (std::exception& e) {
51750       {
51751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51752       };
51753     } catch (Dali::DaliException e) {
51754       {
51755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51756       };
51757     } catch (...) {
51758       {
51759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51760       };
51761     }
51762   }
51763
51764 }
51765
51766
51767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51768   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51769
51770   arg1 = (Dali::Vector< int > *)jarg1;
51771   {
51772     try {
51773       (arg1)->Clear();
51774     } catch (std::out_of_range& e) {
51775       {
51776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51777       };
51778     } catch (std::exception& e) {
51779       {
51780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51781       };
51782     } catch (Dali::DaliException e) {
51783       {
51784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51785       };
51786     } catch (...) {
51787       {
51788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51789       };
51790     }
51791   }
51792
51793 }
51794
51795
51796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51797   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51798
51799   arg1 = (Dali::Vector< int > *)jarg1;
51800   {
51801     try {
51802       (arg1)->Release();
51803     } catch (std::out_of_range& e) {
51804       {
51805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51806       };
51807     } catch (std::exception& e) {
51808       {
51809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51810       };
51811     } catch (Dali::DaliException e) {
51812       {
51813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51814       };
51815     } catch (...) {
51816       {
51817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51818       };
51819     }
51820   }
51821
51822 }
51823
51824
51825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51826   int jresult ;
51827   int result;
51828
51829   result = (int)Dali::Vector< float >::BaseType;
51830   jresult = (int)result;
51831   return jresult;
51832 }
51833
51834
51835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51836   void * jresult ;
51837   Dali::Vector< float > *result = 0 ;
51838
51839   {
51840     try {
51841       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51842     } catch (std::out_of_range& e) {
51843       {
51844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51845       };
51846     } catch (std::exception& e) {
51847       {
51848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51849       };
51850     } catch (Dali::DaliException e) {
51851       {
51852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51853       };
51854     } catch (...) {
51855       {
51856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51857       };
51858     }
51859   }
51860
51861   jresult = (void *)result;
51862   return jresult;
51863 }
51864
51865
51866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51867   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51868
51869   arg1 = (Dali::Vector< float > *)jarg1;
51870   {
51871     try {
51872       delete arg1;
51873     } catch (std::out_of_range& e) {
51874       {
51875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51876       };
51877     } catch (std::exception& e) {
51878       {
51879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51880       };
51881     } catch (Dali::DaliException e) {
51882       {
51883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51884       };
51885     } catch (...) {
51886       {
51887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51888       };
51889     }
51890   }
51891
51892 }
51893
51894
51895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51896   void * jresult ;
51897   Dali::Vector< float > *arg1 = 0 ;
51898   Dali::Vector< float > *result = 0 ;
51899
51900   arg1 = (Dali::Vector< float > *)jarg1;
51901   if (!arg1) {
51902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51903     return 0;
51904   }
51905   {
51906     try {
51907       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51908     } catch (std::out_of_range& e) {
51909       {
51910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51911       };
51912     } catch (std::exception& e) {
51913       {
51914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51915       };
51916     } catch (Dali::DaliException e) {
51917       {
51918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51919       };
51920     } catch (...) {
51921       {
51922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51923       };
51924     }
51925   }
51926
51927   jresult = (void *)result;
51928   return jresult;
51929 }
51930
51931
51932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51933   void * jresult ;
51934   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51935   Dali::Vector< float > *arg2 = 0 ;
51936   Dali::Vector< float > *result = 0 ;
51937
51938   arg1 = (Dali::Vector< float > *)jarg1;
51939   arg2 = (Dali::Vector< float > *)jarg2;
51940   if (!arg2) {
51941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51942     return 0;
51943   }
51944   {
51945     try {
51946       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51947     } catch (std::out_of_range& e) {
51948       {
51949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51950       };
51951     } catch (std::exception& e) {
51952       {
51953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51954       };
51955     } catch (Dali::DaliException e) {
51956       {
51957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51958       };
51959     } catch (...) {
51960       {
51961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51962       };
51963     }
51964   }
51965
51966   jresult = (void *)result;
51967   return jresult;
51968 }
51969
51970
51971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51972   void * jresult ;
51973   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51974   Dali::Vector< float >::Iterator result;
51975
51976   arg1 = (Dali::Vector< float > *)jarg1;
51977   {
51978     try {
51979       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51980     } catch (std::out_of_range& e) {
51981       {
51982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51983       };
51984     } catch (std::exception& e) {
51985       {
51986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51987       };
51988     } catch (Dali::DaliException e) {
51989       {
51990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51991       };
51992     } catch (...) {
51993       {
51994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51995       };
51996     }
51997   }
51998
51999   jresult = (void *)result;
52000   return jresult;
52001 }
52002
52003
52004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
52005   void * jresult ;
52006   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52007   Dali::Vector< float >::Iterator result;
52008
52009   arg1 = (Dali::Vector< float > *)jarg1;
52010   {
52011     try {
52012       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
52013     } catch (std::out_of_range& e) {
52014       {
52015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52016       };
52017     } catch (std::exception& e) {
52018       {
52019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52020       };
52021     } catch (Dali::DaliException e) {
52022       {
52023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52024       };
52025     } catch (...) {
52026       {
52027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52028       };
52029     }
52030   }
52031
52032   jresult = (void *)result;
52033   return jresult;
52034 }
52035
52036
52037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52038   void * jresult ;
52039   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52040   Dali::Vector< float >::SizeType arg2 ;
52041   Dali::Vector< float >::ItemType *result = 0 ;
52042
52043   arg1 = (Dali::Vector< float > *)jarg1;
52044   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52045   {
52046     try {
52047       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
52048     } catch (std::out_of_range& e) {
52049       {
52050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52051       };
52052     } catch (std::exception& e) {
52053       {
52054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52055       };
52056     } catch (Dali::DaliException e) {
52057       {
52058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52059       };
52060     } catch (...) {
52061       {
52062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52063       };
52064     }
52065   }
52066
52067   jresult = (void *)result;
52068   return jresult;
52069 }
52070
52071
52072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
52073   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52074   Dali::Vector< float >::ItemType *arg2 = 0 ;
52075   Dali::Vector< float >::ItemType temp2 ;
52076
52077   arg1 = (Dali::Vector< float > *)jarg1;
52078   temp2 = (Dali::Vector< float >::ItemType)jarg2;
52079   arg2 = &temp2;
52080   {
52081     try {
52082       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
52083     } catch (std::out_of_range& e) {
52084       {
52085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52086       };
52087     } catch (std::exception& e) {
52088       {
52089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52090       };
52091     } catch (Dali::DaliException e) {
52092       {
52093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52094       };
52095     } catch (...) {
52096       {
52097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52098       };
52099     }
52100   }
52101
52102 }
52103
52104
52105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
52106   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52107   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52108   Dali::Vector< float >::ItemType *arg3 = 0 ;
52109   Dali::Vector< float >::ItemType temp3 ;
52110
52111   arg1 = (Dali::Vector< float > *)jarg1;
52112   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52113   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52114   arg3 = &temp3;
52115   {
52116     try {
52117       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52118     } catch (std::out_of_range& e) {
52119       {
52120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52121       };
52122     } catch (std::exception& e) {
52123       {
52124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52125       };
52126     } catch (Dali::DaliException e) {
52127       {
52128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52129       };
52130     } catch (...) {
52131       {
52132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52133       };
52134     }
52135   }
52136
52137 }
52138
52139
52140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
52141   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52142   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52143   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52144   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
52145
52146   arg1 = (Dali::Vector< float > *)jarg1;
52147   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52148   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52149   arg4 = (Dali::Vector< float >::Iterator)jarg4;
52150   {
52151     try {
52152       (arg1)->Insert(arg2,arg3,arg4);
52153     } catch (std::out_of_range& e) {
52154       {
52155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52156       };
52157     } catch (std::exception& e) {
52158       {
52159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52160       };
52161     } catch (Dali::DaliException e) {
52162       {
52163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52164       };
52165     } catch (...) {
52166       {
52167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52168       };
52169     }
52170   }
52171
52172 }
52173
52174
52175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52176   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52177   Dali::Vector< float >::SizeType arg2 ;
52178
52179   arg1 = (Dali::Vector< float > *)jarg1;
52180   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52181   {
52182     try {
52183       (arg1)->Reserve(arg2);
52184     } catch (std::out_of_range& e) {
52185       {
52186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52187       };
52188     } catch (std::exception& e) {
52189       {
52190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52191       };
52192     } catch (Dali::DaliException e) {
52193       {
52194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52195       };
52196     } catch (...) {
52197       {
52198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52199       };
52200     }
52201   }
52202
52203 }
52204
52205 //// ========================= end of part 2 =============================
52206
52207 //// ========================== start part 3 ===============================
52208
52209
52210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52211   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52212   Dali::Vector< float >::SizeType arg2 ;
52213
52214   arg1 = (Dali::Vector< float > *)jarg1;
52215   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52216   {
52217     try {
52218       (arg1)->Resize(arg2);
52219     } catch (std::out_of_range& e) {
52220       {
52221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52222       };
52223     } catch (std::exception& e) {
52224       {
52225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52226       };
52227     } catch (Dali::DaliException e) {
52228       {
52229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52230       };
52231     } catch (...) {
52232       {
52233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52234       };
52235     }
52236   }
52237
52238 }
52239
52240
52241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52242   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52243   Dali::Vector< float >::SizeType arg2 ;
52244   Dali::Vector< float >::ItemType *arg3 = 0 ;
52245   Dali::Vector< float >::ItemType temp3 ;
52246
52247   arg1 = (Dali::Vector< float > *)jarg1;
52248   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52249   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52250   arg3 = &temp3;
52251   {
52252     try {
52253       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52254     } catch (std::out_of_range& e) {
52255       {
52256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52257       };
52258     } catch (std::exception& e) {
52259       {
52260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52261       };
52262     } catch (Dali::DaliException e) {
52263       {
52264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52265       };
52266     } catch (...) {
52267       {
52268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52269       };
52270     }
52271   }
52272
52273 }
52274
52275
52276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52277   void * jresult ;
52278   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52279   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52280   Dali::Vector< float >::Iterator result;
52281
52282   arg1 = (Dali::Vector< float > *)jarg1;
52283   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52284   {
52285     try {
52286       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52287     } catch (std::out_of_range& e) {
52288       {
52289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52290       };
52291     } catch (std::exception& e) {
52292       {
52293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52294       };
52295     } catch (Dali::DaliException e) {
52296       {
52297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52298       };
52299     } catch (...) {
52300       {
52301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52302       };
52303     }
52304   }
52305
52306   jresult = (void *)result;
52307   return jresult;
52308 }
52309
52310
52311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52312   void * jresult ;
52313   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52314   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52315   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52316   Dali::Vector< float >::Iterator result;
52317
52318   arg1 = (Dali::Vector< float > *)jarg1;
52319   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52320   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52321   {
52322     try {
52323       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52324     } catch (std::out_of_range& e) {
52325       {
52326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52327       };
52328     } catch (std::exception& e) {
52329       {
52330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52331       };
52332     } catch (Dali::DaliException e) {
52333       {
52334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52335       };
52336     } catch (...) {
52337       {
52338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52339       };
52340     }
52341   }
52342
52343   jresult = (void *)result;
52344   return jresult;
52345 }
52346
52347
52348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52349   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52350   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52351
52352   arg1 = (Dali::Vector< float > *)jarg1;
52353   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52354   {
52355     try {
52356       (arg1)->Remove(arg2);
52357     } catch (std::out_of_range& e) {
52358       {
52359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52360       };
52361     } catch (std::exception& e) {
52362       {
52363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52364       };
52365     } catch (Dali::DaliException e) {
52366       {
52367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52368       };
52369     } catch (...) {
52370       {
52371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52372       };
52373     }
52374   }
52375
52376 }
52377
52378
52379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52380   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52381   Dali::Vector< float > *arg2 = 0 ;
52382
52383   arg1 = (Dali::Vector< float > *)jarg1;
52384   arg2 = (Dali::Vector< float > *)jarg2;
52385   if (!arg2) {
52386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52387     return ;
52388   }
52389   {
52390     try {
52391       (arg1)->Swap(*arg2);
52392     } catch (std::out_of_range& e) {
52393       {
52394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52395       };
52396     } catch (std::exception& e) {
52397       {
52398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52399       };
52400     } catch (Dali::DaliException e) {
52401       {
52402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52403       };
52404     } catch (...) {
52405       {
52406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52407       };
52408     }
52409   }
52410
52411 }
52412
52413
52414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52415   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52416
52417   arg1 = (Dali::Vector< float > *)jarg1;
52418   {
52419     try {
52420       (arg1)->Clear();
52421     } catch (std::out_of_range& e) {
52422       {
52423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52424       };
52425     } catch (std::exception& e) {
52426       {
52427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52428       };
52429     } catch (Dali::DaliException e) {
52430       {
52431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52432       };
52433     } catch (...) {
52434       {
52435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52436       };
52437     }
52438   }
52439
52440 }
52441
52442
52443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52444   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52445
52446   arg1 = (Dali::Vector< float > *)jarg1;
52447   {
52448     try {
52449       (arg1)->Release();
52450     } catch (std::out_of_range& e) {
52451       {
52452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52453       };
52454     } catch (std::exception& e) {
52455       {
52456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52457       };
52458     } catch (Dali::DaliException e) {
52459       {
52460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52461       };
52462     } catch (...) {
52463       {
52464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52465       };
52466     }
52467   }
52468
52469 }
52470
52471
52472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52473   int jresult ;
52474   int result;
52475
52476   result = (int)Dali::Vector< unsigned char >::BaseType;
52477   jresult = (int)result;
52478   return jresult;
52479 }
52480
52481
52482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52483   void * jresult ;
52484   Dali::Vector< unsigned char > *result = 0 ;
52485
52486   {
52487     try {
52488       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52489     } catch (std::out_of_range& e) {
52490       {
52491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52492       };
52493     } catch (std::exception& e) {
52494       {
52495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52496       };
52497     } catch (Dali::DaliException e) {
52498       {
52499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52500       };
52501     } catch (...) {
52502       {
52503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52504       };
52505     }
52506   }
52507
52508   jresult = (void *)result;
52509   return jresult;
52510 }
52511
52512
52513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52514   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52515
52516   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52517   {
52518     try {
52519       delete arg1;
52520     } catch (std::out_of_range& e) {
52521       {
52522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52523       };
52524     } catch (std::exception& e) {
52525       {
52526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52527       };
52528     } catch (Dali::DaliException e) {
52529       {
52530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52531       };
52532     } catch (...) {
52533       {
52534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52535       };
52536     }
52537   }
52538
52539 }
52540
52541
52542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52543   void * jresult ;
52544   Dali::Vector< unsigned char > *arg1 = 0 ;
52545   Dali::Vector< unsigned char > *result = 0 ;
52546
52547   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52548   if (!arg1) {
52549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52550     return 0;
52551   }
52552   {
52553     try {
52554       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52555     } catch (std::out_of_range& e) {
52556       {
52557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52558       };
52559     } catch (std::exception& e) {
52560       {
52561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52562       };
52563     } catch (Dali::DaliException e) {
52564       {
52565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52566       };
52567     } catch (...) {
52568       {
52569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52570       };
52571     }
52572   }
52573
52574   jresult = (void *)result;
52575   return jresult;
52576 }
52577
52578
52579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52580   void * jresult ;
52581   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52582   Dali::Vector< unsigned char > *arg2 = 0 ;
52583   Dali::Vector< unsigned char > *result = 0 ;
52584
52585   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52586   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52587   if (!arg2) {
52588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52589     return 0;
52590   }
52591   {
52592     try {
52593       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52594     } catch (std::out_of_range& e) {
52595       {
52596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52597       };
52598     } catch (std::exception& e) {
52599       {
52600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52601       };
52602     } catch (Dali::DaliException e) {
52603       {
52604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52605       };
52606     } catch (...) {
52607       {
52608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52609       };
52610     }
52611   }
52612
52613   jresult = (void *)result;
52614   return jresult;
52615 }
52616
52617
52618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52619   void * jresult ;
52620   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52621   Dali::Vector< unsigned char >::Iterator result;
52622
52623   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52624   {
52625     try {
52626       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52627     } catch (std::out_of_range& e) {
52628       {
52629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52630       };
52631     } catch (std::exception& e) {
52632       {
52633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52634       };
52635     } catch (Dali::DaliException e) {
52636       {
52637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52638       };
52639     } catch (...) {
52640       {
52641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52642       };
52643     }
52644   }
52645
52646   jresult = (void *)result;
52647   return jresult;
52648 }
52649
52650
52651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52652   void * jresult ;
52653   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52654   Dali::Vector< unsigned char >::Iterator result;
52655
52656   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52657   {
52658     try {
52659       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52660     } catch (std::out_of_range& e) {
52661       {
52662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52663       };
52664     } catch (std::exception& e) {
52665       {
52666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52667       };
52668     } catch (Dali::DaliException e) {
52669       {
52670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52671       };
52672     } catch (...) {
52673       {
52674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52675       };
52676     }
52677   }
52678
52679   jresult = (void *)result;
52680   return jresult;
52681 }
52682
52683
52684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52685   void * jresult ;
52686   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52687   Dali::Vector< unsigned char >::SizeType arg2 ;
52688   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52689
52690   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52691   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52692   {
52693     try {
52694       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52695     } catch (std::out_of_range& e) {
52696       {
52697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52698       };
52699     } catch (std::exception& e) {
52700       {
52701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52702       };
52703     } catch (Dali::DaliException e) {
52704       {
52705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52706       };
52707     } catch (...) {
52708       {
52709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52710       };
52711     }
52712   }
52713
52714   jresult = (void *)result;
52715   return jresult;
52716 }
52717
52718
52719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52720   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52721   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52722   Dali::Vector< unsigned char >::ItemType temp2 ;
52723
52724   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52725   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52726   arg2 = &temp2;
52727   {
52728     try {
52729       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52730     } catch (std::out_of_range& e) {
52731       {
52732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52733       };
52734     } catch (std::exception& e) {
52735       {
52736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52737       };
52738     } catch (Dali::DaliException e) {
52739       {
52740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52741       };
52742     } catch (...) {
52743       {
52744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52745       };
52746     }
52747   }
52748
52749 }
52750
52751
52752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52753   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52754   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52755   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52756   Dali::Vector< unsigned char >::ItemType temp3 ;
52757
52758   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52759   arg2 = jarg2;
52760   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52761   arg3 = &temp3;
52762   {
52763     try {
52764       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52765     } catch (std::out_of_range& e) {
52766       {
52767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52768       };
52769     } catch (std::exception& e) {
52770       {
52771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52772       };
52773     } catch (Dali::DaliException e) {
52774       {
52775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52776       };
52777     } catch (...) {
52778       {
52779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52780       };
52781     }
52782   }
52783
52784
52785
52786 }
52787
52788
52789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52790   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52791   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52792   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52793   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52794
52795   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52796   arg2 = jarg2;
52797   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52798   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52799   {
52800     try {
52801       (arg1)->Insert(arg2,arg3,arg4);
52802     } catch (std::out_of_range& e) {
52803       {
52804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52805       };
52806     } catch (std::exception& e) {
52807       {
52808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52809       };
52810     } catch (Dali::DaliException e) {
52811       {
52812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52813       };
52814     } catch (...) {
52815       {
52816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52817       };
52818     }
52819   }
52820
52821
52822
52823 }
52824
52825
52826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52827   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52828   Dali::Vector< unsigned char >::SizeType arg2 ;
52829
52830   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52831   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52832   {
52833     try {
52834       (arg1)->Reserve(arg2);
52835     } catch (std::out_of_range& e) {
52836       {
52837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52838       };
52839     } catch (std::exception& e) {
52840       {
52841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52842       };
52843     } catch (Dali::DaliException e) {
52844       {
52845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52846       };
52847     } catch (...) {
52848       {
52849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52850       };
52851     }
52852   }
52853
52854 }
52855
52856
52857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52858   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52859   Dali::Vector< unsigned char >::SizeType arg2 ;
52860
52861   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52862   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52863   {
52864     try {
52865       (arg1)->Resize(arg2);
52866     } catch (std::out_of_range& e) {
52867       {
52868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52869       };
52870     } catch (std::exception& e) {
52871       {
52872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52873       };
52874     } catch (Dali::DaliException e) {
52875       {
52876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52877       };
52878     } catch (...) {
52879       {
52880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52881       };
52882     }
52883   }
52884
52885 }
52886
52887
52888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52889   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52890   Dali::Vector< unsigned char >::SizeType arg2 ;
52891   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52892   Dali::Vector< unsigned char >::ItemType temp3 ;
52893
52894   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52895   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52896   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52897   arg3 = &temp3;
52898   {
52899     try {
52900       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52901     } catch (std::out_of_range& e) {
52902       {
52903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52904       };
52905     } catch (std::exception& e) {
52906       {
52907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52908       };
52909     } catch (Dali::DaliException e) {
52910       {
52911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52912       };
52913     } catch (...) {
52914       {
52915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52916       };
52917     }
52918   }
52919
52920 }
52921
52922
52923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52924   void * jresult ;
52925   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52926   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52927   Dali::Vector< unsigned char >::Iterator result;
52928
52929   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52930   arg2 = jarg2;
52931   {
52932     try {
52933       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52934     } catch (std::out_of_range& e) {
52935       {
52936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52937       };
52938     } catch (std::exception& e) {
52939       {
52940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52941       };
52942     } catch (Dali::DaliException e) {
52943       {
52944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52945       };
52946     } catch (...) {
52947       {
52948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52949       };
52950     }
52951   }
52952
52953   jresult = (void *)result;
52954
52955
52956   return jresult;
52957 }
52958
52959
52960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52961   void * jresult ;
52962   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52963   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52964   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52965   Dali::Vector< unsigned char >::Iterator result;
52966
52967   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52968   arg2 = jarg2;
52969   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52970   {
52971     try {
52972       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52973     } catch (std::out_of_range& e) {
52974       {
52975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52976       };
52977     } catch (std::exception& e) {
52978       {
52979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52980       };
52981     } catch (Dali::DaliException e) {
52982       {
52983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52984       };
52985     } catch (...) {
52986       {
52987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52988       };
52989     }
52990   }
52991
52992   jresult = (void *)result;
52993
52994
52995   return jresult;
52996 }
52997
52998
52999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
53000   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
53001   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
53002
53003   arg1 = (Dali::Vector< unsigned char > *)jarg1;
53004   arg2 = jarg2;
53005   {
53006     try {
53007       (arg1)->Remove(arg2);
53008     } catch (std::out_of_range& e) {
53009       {
53010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53011       };
53012     } catch (std::exception& e) {
53013       {
53014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53015       };
53016     } catch (Dali::DaliException e) {
53017       {
53018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53019       };
53020     } catch (...) {
53021       {
53022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53023       };
53024     }
53025   }
53026
53027
53028
53029 }
53030
53031
53032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
53033   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
53034   Dali::Vector< unsigned char > *arg2 = 0 ;
53035
53036   arg1 = (Dali::Vector< unsigned char > *)jarg1;
53037   arg2 = (Dali::Vector< unsigned char > *)jarg2;
53038   if (!arg2) {
53039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
53040     return ;
53041   }
53042   {
53043     try {
53044       (arg1)->Swap(*arg2);
53045     } catch (std::out_of_range& e) {
53046       {
53047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53048       };
53049     } catch (std::exception& e) {
53050       {
53051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53052       };
53053     } catch (Dali::DaliException e) {
53054       {
53055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53056       };
53057     } catch (...) {
53058       {
53059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53060       };
53061     }
53062   }
53063
53064 }
53065
53066
53067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
53068   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
53069
53070   arg1 = (Dali::Vector< unsigned char > *)jarg1;
53071   {
53072     try {
53073       (arg1)->Clear();
53074     } catch (std::out_of_range& e) {
53075       {
53076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53077       };
53078     } catch (std::exception& e) {
53079       {
53080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53081       };
53082     } catch (Dali::DaliException e) {
53083       {
53084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53085       };
53086     } catch (...) {
53087       {
53088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53089       };
53090     }
53091   }
53092
53093 }
53094
53095
53096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
53097   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
53098
53099   arg1 = (Dali::Vector< unsigned char > *)jarg1;
53100   {
53101     try {
53102       (arg1)->Release();
53103     } catch (std::out_of_range& e) {
53104       {
53105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53106       };
53107     } catch (std::exception& e) {
53108       {
53109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53110       };
53111     } catch (Dali::DaliException e) {
53112       {
53113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53114       };
53115     } catch (...) {
53116       {
53117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53118       };
53119     }
53120   }
53121
53122 }
53123
53124
53125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
53126   int jresult ;
53127   int result;
53128
53129   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
53130   jresult = (int)result;
53131   return jresult;
53132 }
53133
53134
53135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
53136   void * jresult ;
53137   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53138
53139   {
53140     try {
53141       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
53142     } catch (std::out_of_range& e) {
53143       {
53144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53145       };
53146     } catch (std::exception& e) {
53147       {
53148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53149       };
53150     } catch (Dali::DaliException e) {
53151       {
53152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53153       };
53154     } catch (...) {
53155       {
53156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53157       };
53158     }
53159   }
53160
53161   jresult = (void *)result;
53162   return jresult;
53163 }
53164
53165
53166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
53167   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53168
53169   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53170   {
53171     try {
53172       delete arg1;
53173     } catch (std::out_of_range& e) {
53174       {
53175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53176       };
53177     } catch (std::exception& e) {
53178       {
53179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53180       };
53181     } catch (Dali::DaliException e) {
53182       {
53183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53184       };
53185     } catch (...) {
53186       {
53187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53188       };
53189     }
53190   }
53191
53192 }
53193
53194
53195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53196   void * jresult ;
53197   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53198   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53199
53200   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53201   if (!arg1) {
53202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53203     return 0;
53204   }
53205   {
53206     try {
53207       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53208     } catch (std::out_of_range& e) {
53209       {
53210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53211       };
53212     } catch (std::exception& e) {
53213       {
53214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53215       };
53216     } catch (Dali::DaliException e) {
53217       {
53218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53219       };
53220     } catch (...) {
53221       {
53222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53223       };
53224     }
53225   }
53226
53227   jresult = (void *)result;
53228   return jresult;
53229 }
53230
53231
53232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53233   void * jresult ;
53234   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53235   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53236   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53237
53238   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53239   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53240   if (!arg2) {
53241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53242     return 0;
53243   }
53244   {
53245     try {
53246       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
53247     } catch (std::out_of_range& e) {
53248       {
53249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53250       };
53251     } catch (std::exception& e) {
53252       {
53253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53254       };
53255     } catch (Dali::DaliException e) {
53256       {
53257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53258       };
53259     } catch (...) {
53260       {
53261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53262       };
53263     }
53264   }
53265
53266   jresult = (void *)result;
53267   return jresult;
53268 }
53269
53270
53271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53272   void * jresult ;
53273   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53274   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53275
53276   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53277   {
53278     try {
53279       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53280     } catch (std::out_of_range& e) {
53281       {
53282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53283       };
53284     } catch (std::exception& e) {
53285       {
53286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53287       };
53288     } catch (Dali::DaliException e) {
53289       {
53290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53291       };
53292     } catch (...) {
53293       {
53294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53295       };
53296     }
53297   }
53298
53299   jresult = (void *)result;
53300   return jresult;
53301 }
53302
53303
53304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53305   void * jresult ;
53306   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53307   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53308
53309   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53310   {
53311     try {
53312       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53313     } catch (std::out_of_range& e) {
53314       {
53315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53316       };
53317     } catch (std::exception& e) {
53318       {
53319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53320       };
53321     } catch (Dali::DaliException e) {
53322       {
53323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53324       };
53325     } catch (...) {
53326       {
53327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53328       };
53329     }
53330   }
53331
53332   jresult = (void *)result;
53333   return jresult;
53334 }
53335
53336
53337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53338   void * jresult ;
53339   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53340   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53341   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53342
53343   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53344   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53345   {
53346     try {
53347       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53348     } catch (std::out_of_range& e) {
53349       {
53350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53351       };
53352     } catch (std::exception& e) {
53353       {
53354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53355       };
53356     } catch (Dali::DaliException e) {
53357       {
53358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53359       };
53360     } catch (...) {
53361       {
53362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53363       };
53364     }
53365   }
53366
53367   jresult = (void *)result;
53368   return jresult;
53369 }
53370
53371
53372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53373   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53374   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53375
53376   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53377   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53378   if (!arg2) {
53379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53380     return ;
53381   }
53382   {
53383     try {
53384       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53385     } catch (std::out_of_range& e) {
53386       {
53387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53388       };
53389     } catch (std::exception& e) {
53390       {
53391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53392       };
53393     } catch (Dali::DaliException e) {
53394       {
53395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53396       };
53397     } catch (...) {
53398       {
53399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53400       };
53401     }
53402   }
53403
53404 }
53405
53406
53407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53408   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53409   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53410   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53411
53412   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53413   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53414   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53415   if (!arg3) {
53416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53417     return ;
53418   }
53419   {
53420     try {
53421       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53422     } catch (std::out_of_range& e) {
53423       {
53424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53425       };
53426     } catch (std::exception& e) {
53427       {
53428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53429       };
53430     } catch (Dali::DaliException e) {
53431       {
53432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53433       };
53434     } catch (...) {
53435       {
53436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53437       };
53438     }
53439   }
53440
53441 }
53442
53443
53444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53445   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53446   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53447   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53448   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53449
53450   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53451   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53452   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53453   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53454   {
53455     try {
53456       (arg1)->Insert(arg2,arg3,arg4);
53457     } catch (std::out_of_range& e) {
53458       {
53459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53460       };
53461     } catch (std::exception& e) {
53462       {
53463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53464       };
53465     } catch (Dali::DaliException e) {
53466       {
53467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53468       };
53469     } catch (...) {
53470       {
53471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53472       };
53473     }
53474   }
53475
53476 }
53477
53478
53479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53480   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53481   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53482
53483   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53484   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53485   {
53486     try {
53487       (arg1)->Reserve(arg2);
53488     } catch (std::out_of_range& e) {
53489       {
53490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53491       };
53492     } catch (std::exception& e) {
53493       {
53494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53495       };
53496     } catch (Dali::DaliException e) {
53497       {
53498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53499       };
53500     } catch (...) {
53501       {
53502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53503       };
53504     }
53505   }
53506
53507 }
53508
53509
53510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53511   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53512   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53513
53514   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53515   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53516   {
53517     try {
53518       (arg1)->Resize(arg2);
53519     } catch (std::out_of_range& e) {
53520       {
53521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53522       };
53523     } catch (std::exception& e) {
53524       {
53525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53526       };
53527     } catch (Dali::DaliException e) {
53528       {
53529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53530       };
53531     } catch (...) {
53532       {
53533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53534       };
53535     }
53536   }
53537
53538 }
53539
53540
53541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53542   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53543   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53544   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53545
53546   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53547   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53548   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53549   if (!arg3) {
53550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53551     return ;
53552   }
53553   {
53554     try {
53555       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53556     } catch (std::out_of_range& e) {
53557       {
53558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53559       };
53560     } catch (std::exception& e) {
53561       {
53562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53563       };
53564     } catch (Dali::DaliException e) {
53565       {
53566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53567       };
53568     } catch (...) {
53569       {
53570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53571       };
53572     }
53573   }
53574
53575 }
53576
53577
53578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53579   void * jresult ;
53580   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53581   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53582   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53583
53584   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53585   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53586   {
53587     try {
53588       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53589     } catch (std::out_of_range& e) {
53590       {
53591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53592       };
53593     } catch (std::exception& e) {
53594       {
53595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53596       };
53597     } catch (Dali::DaliException e) {
53598       {
53599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53600       };
53601     } catch (...) {
53602       {
53603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53604       };
53605     }
53606   }
53607
53608   jresult = (void *)result;
53609   return jresult;
53610 }
53611
53612
53613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53614   void * jresult ;
53615   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53616   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53617   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53618   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53619
53620   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53621   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53622   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53623   {
53624     try {
53625       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53626     } catch (std::out_of_range& e) {
53627       {
53628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53629       };
53630     } catch (std::exception& e) {
53631       {
53632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53633       };
53634     } catch (Dali::DaliException e) {
53635       {
53636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53637       };
53638     } catch (...) {
53639       {
53640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53641       };
53642     }
53643   }
53644
53645   jresult = (void *)result;
53646   return jresult;
53647 }
53648
53649
53650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53651   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53652   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53653
53654   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53655   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53656   {
53657     try {
53658       (arg1)->Remove(arg2);
53659     } catch (std::out_of_range& e) {
53660       {
53661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53662       };
53663     } catch (std::exception& e) {
53664       {
53665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53666       };
53667     } catch (Dali::DaliException e) {
53668       {
53669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53670       };
53671     } catch (...) {
53672       {
53673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53674       };
53675     }
53676   }
53677
53678 }
53679
53680
53681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53682   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53683   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53684
53685   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53686   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53687   if (!arg2) {
53688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53689     return ;
53690   }
53691   {
53692     try {
53693       (arg1)->Swap(*arg2);
53694     } catch (std::out_of_range& e) {
53695       {
53696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53697       };
53698     } catch (std::exception& e) {
53699       {
53700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53701       };
53702     } catch (Dali::DaliException e) {
53703       {
53704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53705       };
53706     } catch (...) {
53707       {
53708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53709       };
53710     }
53711   }
53712
53713 }
53714
53715
53716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53717   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53718
53719   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53720   {
53721     try {
53722       (arg1)->Clear();
53723     } catch (std::out_of_range& e) {
53724       {
53725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53726       };
53727     } catch (std::exception& e) {
53728       {
53729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53730       };
53731     } catch (Dali::DaliException e) {
53732       {
53733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53734       };
53735     } catch (...) {
53736       {
53737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53738       };
53739     }
53740   }
53741
53742 }
53743
53744
53745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53746   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53747
53748   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53749   {
53750     try {
53751       (arg1)->Release();
53752     } catch (std::out_of_range& e) {
53753       {
53754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53755       };
53756     } catch (std::exception& e) {
53757       {
53758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53759       };
53760     } catch (Dali::DaliException e) {
53761       {
53762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53763       };
53764     } catch (...) {
53765       {
53766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53767       };
53768     }
53769   }
53770
53771 }
53772
53773
53774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53775   void * jresult ;
53776   Dali::Signal< void () > *result = 0 ;
53777
53778   {
53779     try {
53780       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53781     } catch (std::out_of_range& e) {
53782       {
53783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53784       };
53785     } catch (std::exception& e) {
53786       {
53787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53788       };
53789     } catch (Dali::DaliException e) {
53790       {
53791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53792       };
53793     } catch (...) {
53794       {
53795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53796       };
53797     }
53798   }
53799
53800   jresult = (void *)result;
53801   return jresult;
53802 }
53803
53804
53805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53806   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53807
53808   arg1 = (Dali::Signal< void () > *)jarg1;
53809   {
53810     try {
53811       delete arg1;
53812     } catch (std::out_of_range& e) {
53813       {
53814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53815       };
53816     } catch (std::exception& e) {
53817       {
53818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53819       };
53820     } catch (Dali::DaliException e) {
53821       {
53822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53823       };
53824     } catch (...) {
53825       {
53826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53827       };
53828     }
53829   }
53830
53831 }
53832
53833
53834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53835   unsigned int jresult ;
53836   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53837   bool result;
53838
53839   arg1 = (Dali::Signal< void () > *)jarg1;
53840   {
53841     try {
53842       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53843     } catch (std::out_of_range& e) {
53844       {
53845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53846       };
53847     } catch (std::exception& e) {
53848       {
53849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53850       };
53851     } catch (Dali::DaliException e) {
53852       {
53853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53854       };
53855     } catch (...) {
53856       {
53857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53858       };
53859     }
53860   }
53861
53862   jresult = result;
53863   return jresult;
53864 }
53865
53866
53867 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53868   unsigned long jresult ;
53869   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53870   std::size_t result;
53871
53872   arg1 = (Dali::Signal< void () > *)jarg1;
53873   {
53874     try {
53875       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53876     } catch (std::out_of_range& e) {
53877       {
53878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53879       };
53880     } catch (std::exception& e) {
53881       {
53882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53883       };
53884     } catch (Dali::DaliException e) {
53885       {
53886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53887       };
53888     } catch (...) {
53889       {
53890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53891       };
53892     }
53893   }
53894
53895   jresult = (unsigned long)result;
53896   return jresult;
53897 }
53898
53899
53900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53901   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53902   void (*arg2)() = (void (*)()) 0 ;
53903
53904   arg1 = (Dali::Signal< void () > *)jarg1;
53905   arg2 = (void (*)())jarg2;
53906   {
53907     try {
53908       (arg1)->Connect(arg2);
53909     } catch (std::out_of_range& e) {
53910       {
53911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53912       };
53913     } catch (std::exception& e) {
53914       {
53915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53916       };
53917     } catch (Dali::DaliException e) {
53918       {
53919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53920       };
53921     } catch (...) {
53922       {
53923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53924       };
53925     }
53926   }
53927
53928 }
53929
53930
53931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53932   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53933   void (*arg2)() = (void (*)()) 0 ;
53934
53935   arg1 = (Dali::Signal< void () > *)jarg1;
53936   arg2 = (void (*)())jarg2;
53937   {
53938     try {
53939       (arg1)->Disconnect(arg2);
53940     } catch (std::out_of_range& e) {
53941       {
53942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53943       };
53944     } catch (std::exception& e) {
53945       {
53946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53947       };
53948     } catch (Dali::DaliException e) {
53949       {
53950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53951       };
53952     } catch (...) {
53953       {
53954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53955       };
53956     }
53957   }
53958
53959 }
53960
53961
53962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53963   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53964   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53965   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53966
53967   arg1 = (Dali::Signal< void () > *)jarg1;
53968   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53969   arg3 = (Dali::FunctorDelegate *)jarg3;
53970   {
53971     try {
53972       (arg1)->Connect(arg2,arg3);
53973     } catch (std::out_of_range& e) {
53974       {
53975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53976       };
53977     } catch (std::exception& e) {
53978       {
53979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53980       };
53981     } catch (Dali::DaliException e) {
53982       {
53983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53984       };
53985     } catch (...) {
53986       {
53987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53988       };
53989     }
53990   }
53991
53992 }
53993
53994
53995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53996   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53997
53998   arg1 = (Dali::Signal< void () > *)jarg1;
53999   {
54000     try {
54001       (arg1)->Emit();
54002     } catch (std::out_of_range& e) {
54003       {
54004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54005       };
54006     } catch (std::exception& e) {
54007       {
54008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54009       };
54010     } catch (Dali::DaliException e) {
54011       {
54012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54013       };
54014     } catch (...) {
54015       {
54016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54017       };
54018     }
54019   }
54020
54021 }
54022
54023
54024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
54025   unsigned int jresult ;
54026   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54027   bool result;
54028
54029   arg1 = (Dali::Signal< void (float) > *)jarg1;
54030   {
54031     try {
54032       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
54033     } catch (std::out_of_range& e) {
54034       {
54035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54036       };
54037     } catch (std::exception& e) {
54038       {
54039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54040       };
54041     } catch (Dali::DaliException e) {
54042       {
54043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54044       };
54045     } catch (...) {
54046       {
54047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54048       };
54049     }
54050   }
54051
54052   jresult = result;
54053   return jresult;
54054 }
54055
54056
54057 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
54058   unsigned long jresult ;
54059   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54060   std::size_t result;
54061
54062   arg1 = (Dali::Signal< void (float) > *)jarg1;
54063   {
54064     try {
54065       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
54066     } catch (std::out_of_range& e) {
54067       {
54068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54069       };
54070     } catch (std::exception& e) {
54071       {
54072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54073       };
54074     } catch (Dali::DaliException e) {
54075       {
54076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54077       };
54078     } catch (...) {
54079       {
54080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54081       };
54082     }
54083   }
54084
54085   jresult = (unsigned long)result;
54086   return jresult;
54087 }
54088
54089
54090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
54091   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54092   void (*arg2)(float) = (void (*)(float)) 0 ;
54093
54094   arg1 = (Dali::Signal< void (float) > *)jarg1;
54095   arg2 = (void (*)(float))jarg2;
54096   {
54097     try {
54098       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
54099     } catch (std::out_of_range& e) {
54100       {
54101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54102       };
54103     } catch (std::exception& e) {
54104       {
54105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54106       };
54107     } catch (Dali::DaliException e) {
54108       {
54109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54110       };
54111     } catch (...) {
54112       {
54113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54114       };
54115     }
54116   }
54117
54118 }
54119
54120
54121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
54122   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54123   void (*arg2)(float) = (void (*)(float)) 0 ;
54124
54125   arg1 = (Dali::Signal< void (float) > *)jarg1;
54126   arg2 = (void (*)(float))jarg2;
54127   {
54128     try {
54129       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
54130     } catch (std::out_of_range& e) {
54131       {
54132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54133       };
54134     } catch (std::exception& e) {
54135       {
54136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54137       };
54138     } catch (Dali::DaliException e) {
54139       {
54140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54141       };
54142     } catch (...) {
54143       {
54144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54145       };
54146     }
54147   }
54148
54149 }
54150
54151
54152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
54153   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54154   float arg2 ;
54155
54156   arg1 = (Dali::Signal< void (float) > *)jarg1;
54157   arg2 = (float)jarg2;
54158   {
54159     try {
54160       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
54161     } catch (std::out_of_range& e) {
54162       {
54163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54164       };
54165     } catch (std::exception& e) {
54166       {
54167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54168       };
54169     } catch (Dali::DaliException e) {
54170       {
54171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54172       };
54173     } catch (...) {
54174       {
54175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54176       };
54177     }
54178   }
54179
54180 }
54181
54182
54183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54184   void * jresult ;
54185   Dali::Signal< void (float) > *result = 0 ;
54186
54187   {
54188     try {
54189       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54190     } catch (std::out_of_range& e) {
54191       {
54192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54193       };
54194     } catch (std::exception& e) {
54195       {
54196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54197       };
54198     } catch (Dali::DaliException e) {
54199       {
54200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54201       };
54202     } catch (...) {
54203       {
54204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54205       };
54206     }
54207   }
54208
54209   jresult = (void *)result;
54210   return jresult;
54211 }
54212
54213
54214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54215   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54216
54217   arg1 = (Dali::Signal< void (float) > *)jarg1;
54218   {
54219     try {
54220       delete arg1;
54221     } catch (std::out_of_range& e) {
54222       {
54223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54224       };
54225     } catch (std::exception& e) {
54226       {
54227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54228       };
54229     } catch (Dali::DaliException e) {
54230       {
54231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54232       };
54233     } catch (...) {
54234       {
54235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54236       };
54237     }
54238   }
54239
54240 }
54241
54242
54243 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54244   unsigned int jresult ;
54245   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54246   bool result;
54247
54248   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54249   {
54250     try {
54251       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54252     } catch (std::out_of_range& e) {
54253       {
54254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54255       };
54256     } catch (std::exception& e) {
54257       {
54258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54259       };
54260     } catch (Dali::DaliException e) {
54261       {
54262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54263       };
54264     } catch (...) {
54265       {
54266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54267       };
54268     }
54269   }
54270
54271   jresult = result;
54272   return jresult;
54273 }
54274
54275
54276 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54277   unsigned long jresult ;
54278   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54279   std::size_t result;
54280
54281   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54282   {
54283     try {
54284       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54285     } catch (std::out_of_range& e) {
54286       {
54287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54288       };
54289     } catch (std::exception& e) {
54290       {
54291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54292       };
54293     } catch (Dali::DaliException e) {
54294       {
54295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54296       };
54297     } catch (...) {
54298       {
54299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54300       };
54301     }
54302   }
54303
54304   jresult = (unsigned long)result;
54305   return jresult;
54306 }
54307
54308
54309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54310   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54311   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54312
54313   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54314   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54315   {
54316     try {
54317       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54318     } catch (std::out_of_range& e) {
54319       {
54320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54321       };
54322     } catch (std::exception& e) {
54323       {
54324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54325       };
54326     } catch (Dali::DaliException e) {
54327       {
54328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54329       };
54330     } catch (...) {
54331       {
54332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54333       };
54334     }
54335   }
54336
54337 }
54338
54339
54340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54341   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54342   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54343
54344   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54345   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54346   {
54347     try {
54348       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54349     } catch (std::out_of_range& e) {
54350       {
54351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54352       };
54353     } catch (std::exception& e) {
54354       {
54355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54356       };
54357     } catch (Dali::DaliException e) {
54358       {
54359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54360       };
54361     } catch (...) {
54362       {
54363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54364       };
54365     }
54366   }
54367
54368 }
54369
54370
54371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54372   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54373   Dali::BaseHandle arg2 ;
54374   Dali::BaseHandle *argp2 ;
54375
54376   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54377   argp2 = (Dali::BaseHandle *)jarg2;
54378   if (!argp2) {
54379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54380     return ;
54381   }
54382   arg2 = *argp2;
54383   {
54384     try {
54385       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54386     } catch (std::out_of_range& e) {
54387       {
54388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54389       };
54390     } catch (std::exception& e) {
54391       {
54392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54393       };
54394     } catch (Dali::DaliException e) {
54395       {
54396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54397       };
54398     } catch (...) {
54399       {
54400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54401       };
54402     }
54403   }
54404
54405 }
54406
54407
54408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54409   void * jresult ;
54410   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54411
54412   {
54413     try {
54414       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54415     } catch (std::out_of_range& e) {
54416       {
54417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54418       };
54419     } catch (std::exception& e) {
54420       {
54421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54422       };
54423     } catch (Dali::DaliException e) {
54424       {
54425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54426       };
54427     } catch (...) {
54428       {
54429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54430       };
54431     }
54432   }
54433
54434   jresult = (void *)result;
54435   return jresult;
54436 }
54437
54438
54439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54440   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54441
54442   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54443   {
54444     try {
54445       delete arg1;
54446     } catch (std::out_of_range& e) {
54447       {
54448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54449       };
54450     } catch (std::exception& e) {
54451       {
54452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54453       };
54454     } catch (Dali::DaliException e) {
54455       {
54456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54457       };
54458     } catch (...) {
54459       {
54460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54461       };
54462     }
54463   }
54464
54465 }
54466
54467
54468 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54469   unsigned int jresult ;
54470   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54471   bool result;
54472
54473   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54474   {
54475     try {
54476       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54477     } catch (std::out_of_range& e) {
54478       {
54479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54480       };
54481     } catch (std::exception& e) {
54482       {
54483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54484       };
54485     } catch (Dali::DaliException e) {
54486       {
54487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54488       };
54489     } catch (...) {
54490       {
54491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54492       };
54493     }
54494   }
54495
54496   jresult = result;
54497   return jresult;
54498 }
54499
54500
54501 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54502   unsigned long jresult ;
54503   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54504   std::size_t result;
54505
54506   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54507   {
54508     try {
54509       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54510     } catch (std::out_of_range& e) {
54511       {
54512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54513       };
54514     } catch (std::exception& e) {
54515       {
54516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54517       };
54518     } catch (Dali::DaliException e) {
54519       {
54520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54521       };
54522     } catch (...) {
54523       {
54524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54525       };
54526     }
54527   }
54528
54529   jresult = (unsigned long)result;
54530   return jresult;
54531 }
54532
54533
54534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54535   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54536   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54537
54538   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54539   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54540   {
54541     try {
54542       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54543     } catch (std::out_of_range& e) {
54544       {
54545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54546       };
54547     } catch (std::exception& e) {
54548       {
54549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54550       };
54551     } catch (Dali::DaliException e) {
54552       {
54553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54554       };
54555     } catch (...) {
54556       {
54557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54558       };
54559     }
54560   }
54561
54562 }
54563
54564
54565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54566   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54567   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54568
54569   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54570   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54571   {
54572     try {
54573       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54574     } catch (std::out_of_range& e) {
54575       {
54576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54577       };
54578     } catch (std::exception& e) {
54579       {
54580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54581       };
54582     } catch (Dali::DaliException e) {
54583       {
54584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54585       };
54586     } catch (...) {
54587       {
54588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54589       };
54590     }
54591   }
54592
54593 }
54594
54595
54596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54597   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54598   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54599
54600   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54601   arg2 = (Dali::RefObject *)jarg2;
54602   {
54603     try {
54604       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54605     } catch (std::out_of_range& e) {
54606       {
54607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54608       };
54609     } catch (std::exception& e) {
54610       {
54611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54612       };
54613     } catch (Dali::DaliException e) {
54614       {
54615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54616       };
54617     } catch (...) {
54618       {
54619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54620       };
54621     }
54622   }
54623
54624 }
54625
54626
54627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54628   void * jresult ;
54629   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54630
54631   {
54632     try {
54633       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54634     } catch (std::out_of_range& e) {
54635       {
54636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54637       };
54638     } catch (std::exception& e) {
54639       {
54640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54641       };
54642     } catch (Dali::DaliException e) {
54643       {
54644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54645       };
54646     } catch (...) {
54647       {
54648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54649       };
54650     }
54651   }
54652
54653   jresult = (void *)result;
54654   return jresult;
54655 }
54656
54657
54658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54659   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54660
54661   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54662   {
54663     try {
54664       delete arg1;
54665     } catch (std::out_of_range& e) {
54666       {
54667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54668       };
54669     } catch (std::exception& e) {
54670       {
54671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54672       };
54673     } catch (Dali::DaliException e) {
54674       {
54675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54676       };
54677     } catch (...) {
54678       {
54679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54680       };
54681     }
54682   }
54683
54684 }
54685
54686
54687 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54688   unsigned int jresult ;
54689   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54690   bool result;
54691
54692   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54693   {
54694     try {
54695       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54696     } catch (std::out_of_range& e) {
54697       {
54698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54699       };
54700     } catch (std::exception& e) {
54701       {
54702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54703       };
54704     } catch (Dali::DaliException e) {
54705       {
54706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54707       };
54708     } catch (...) {
54709       {
54710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54711       };
54712     }
54713   }
54714
54715   jresult = result;
54716   return jresult;
54717 }
54718
54719
54720 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54721   unsigned long jresult ;
54722   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54723   std::size_t result;
54724
54725   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54726   {
54727     try {
54728       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54729     } catch (std::out_of_range& e) {
54730       {
54731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54732       };
54733     } catch (std::exception& e) {
54734       {
54735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54736       };
54737     } catch (Dali::DaliException e) {
54738       {
54739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54740       };
54741     } catch (...) {
54742       {
54743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54744       };
54745     }
54746   }
54747
54748   jresult = (unsigned long)result;
54749   return jresult;
54750 }
54751
54752
54753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54754   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54755   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54756
54757   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54758   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54759   {
54760     try {
54761       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54762     } catch (std::out_of_range& e) {
54763       {
54764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54765       };
54766     } catch (std::exception& e) {
54767       {
54768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54769       };
54770     } catch (Dali::DaliException e) {
54771       {
54772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54773       };
54774     } catch (...) {
54775       {
54776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54777       };
54778     }
54779   }
54780
54781 }
54782
54783
54784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54785   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54786   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54787
54788   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54789   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54790   {
54791     try {
54792       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54793     } catch (std::out_of_range& e) {
54794       {
54795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54796       };
54797     } catch (std::exception& e) {
54798       {
54799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54800       };
54801     } catch (Dali::DaliException e) {
54802       {
54803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54804       };
54805     } catch (...) {
54806       {
54807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54808       };
54809     }
54810   }
54811
54812 }
54813
54814
54815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54816   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54817   Dali::PropertyNotification *arg2 = 0 ;
54818
54819   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54820   arg2 = (Dali::PropertyNotification *)jarg2;
54821   if (!arg2) {
54822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54823     return ;
54824   }
54825   {
54826     try {
54827       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54828     } catch (std::out_of_range& e) {
54829       {
54830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54831       };
54832     } catch (std::exception& e) {
54833       {
54834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54835       };
54836     } catch (Dali::DaliException e) {
54837       {
54838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54839       };
54840     } catch (...) {
54841       {
54842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54843       };
54844     }
54845   }
54846
54847 }
54848
54849
54850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54851   void * jresult ;
54852   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54853
54854   {
54855     try {
54856       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54857     } catch (std::out_of_range& e) {
54858       {
54859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54860       };
54861     } catch (std::exception& e) {
54862       {
54863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54864       };
54865     } catch (Dali::DaliException e) {
54866       {
54867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54868       };
54869     } catch (...) {
54870       {
54871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54872       };
54873     }
54874   }
54875
54876   jresult = (void *)result;
54877   return jresult;
54878 }
54879
54880
54881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54882   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54883
54884   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54885   {
54886     try {
54887       delete arg1;
54888     } catch (std::out_of_range& e) {
54889       {
54890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54891       };
54892     } catch (std::exception& e) {
54893       {
54894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54895       };
54896     } catch (Dali::DaliException e) {
54897       {
54898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54899       };
54900     } catch (...) {
54901       {
54902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54903       };
54904     }
54905   }
54906
54907 }
54908
54909
54910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54911   unsigned int jresult ;
54912   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54913   bool result;
54914
54915   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54916   {
54917     try {
54918       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54919     } catch (std::out_of_range& e) {
54920       {
54921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54922       };
54923     } catch (std::exception& e) {
54924       {
54925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54926       };
54927     } catch (Dali::DaliException e) {
54928       {
54929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54930       };
54931     } catch (...) {
54932       {
54933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54934       };
54935     }
54936   }
54937
54938   jresult = result;
54939   return jresult;
54940 }
54941
54942
54943 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54944   unsigned long jresult ;
54945   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54946   std::size_t result;
54947
54948   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54949   {
54950     try {
54951       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54952     } catch (std::out_of_range& e) {
54953       {
54954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54955       };
54956     } catch (std::exception& e) {
54957       {
54958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54959       };
54960     } catch (Dali::DaliException e) {
54961       {
54962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54963       };
54964     } catch (...) {
54965       {
54966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54967       };
54968     }
54969   }
54970
54971   jresult = (unsigned long)result;
54972   return jresult;
54973 }
54974
54975
54976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54977   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54978   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54979
54980   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54981   arg2 = (void (*)(Dali::Image))jarg2;
54982   {
54983     try {
54984       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54985     } catch (std::out_of_range& e) {
54986       {
54987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54988       };
54989     } catch (std::exception& e) {
54990       {
54991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54992       };
54993     } catch (Dali::DaliException e) {
54994       {
54995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54996       };
54997     } catch (...) {
54998       {
54999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55000       };
55001     }
55002   }
55003
55004 }
55005
55006
55007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
55008   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
55009   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
55010
55011   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
55012   arg2 = (void (*)(Dali::Image))jarg2;
55013   {
55014     try {
55015       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
55016     } catch (std::out_of_range& e) {
55017       {
55018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55019       };
55020     } catch (std::exception& e) {
55021       {
55022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55023       };
55024     } catch (Dali::DaliException e) {
55025       {
55026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55027       };
55028     } catch (...) {
55029       {
55030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55031       };
55032     }
55033   }
55034
55035 }
55036
55037
55038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
55039   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
55040   Dali::Image arg2 ;
55041   Dali::Image *argp2 ;
55042
55043   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
55044   argp2 = (Dali::Image *)jarg2;
55045   if (!argp2) {
55046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
55047     return ;
55048   }
55049   arg2 = *argp2;
55050   {
55051     try {
55052       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
55053     } catch (std::out_of_range& e) {
55054       {
55055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55056       };
55057     } catch (std::exception& e) {
55058       {
55059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55060       };
55061     } catch (Dali::DaliException e) {
55062       {
55063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55064       };
55065     } catch (...) {
55066       {
55067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55068       };
55069     }
55070   }
55071
55072 }
55073
55074
55075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
55076   void * jresult ;
55077   Dali::Signal< void (Dali::Image) > *result = 0 ;
55078
55079   {
55080     try {
55081       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
55082     } catch (std::out_of_range& e) {
55083       {
55084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55085       };
55086     } catch (std::exception& e) {
55087       {
55088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55089       };
55090     } catch (Dali::DaliException e) {
55091       {
55092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55093       };
55094     } catch (...) {
55095       {
55096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55097       };
55098     }
55099   }
55100
55101   jresult = (void *)result;
55102   return jresult;
55103 }
55104
55105
55106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
55107   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
55108
55109   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
55110   {
55111     try {
55112       delete arg1;
55113     } catch (std::out_of_range& e) {
55114       {
55115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55116       };
55117     } catch (std::exception& e) {
55118       {
55119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55120       };
55121     } catch (Dali::DaliException e) {
55122       {
55123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55124       };
55125     } catch (...) {
55126       {
55127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55128       };
55129     }
55130   }
55131
55132 }
55133
55134
55135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
55136   void * jresult ;
55137   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
55138
55139   {
55140     try {
55141       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
55142     } catch (std::out_of_range& e) {
55143       {
55144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55145       };
55146     } catch (std::exception& e) {
55147       {
55148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55149       };
55150     } catch (Dali::DaliException e) {
55151       {
55152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55153       };
55154     } catch (...) {
55155       {
55156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55157       };
55158     }
55159   }
55160
55161   jresult = (void *)result;
55162   return jresult;
55163 }
55164
55165
55166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
55167   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
55168
55169   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55170   {
55171     try {
55172       delete arg1;
55173     } catch (std::out_of_range& e) {
55174       {
55175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55176       };
55177     } catch (std::exception& e) {
55178       {
55179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55180       };
55181     } catch (Dali::DaliException e) {
55182       {
55183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55184       };
55185     } catch (...) {
55186       {
55187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55188       };
55189     }
55190   }
55191
55192 }
55193
55194
55195 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55196   unsigned int jresult ;
55197   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55198   bool result;
55199
55200   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55201   {
55202     try {
55203       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);
55204     } catch (std::out_of_range& e) {
55205       {
55206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55207       };
55208     } catch (std::exception& e) {
55209       {
55210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55211       };
55212     } catch (Dali::DaliException e) {
55213       {
55214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55215       };
55216     } catch (...) {
55217       {
55218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55219       };
55220     }
55221   }
55222
55223   jresult = result;
55224   return jresult;
55225 }
55226
55227
55228 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55229   unsigned long jresult ;
55230   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55231   std::size_t result;
55232
55233   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55234   {
55235     try {
55236       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);
55237     } catch (std::out_of_range& e) {
55238       {
55239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55240       };
55241     } catch (std::exception& e) {
55242       {
55243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55244       };
55245     } catch (Dali::DaliException e) {
55246       {
55247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55248       };
55249     } catch (...) {
55250       {
55251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55252       };
55253     }
55254   }
55255
55256   jresult = (unsigned long)result;
55257   return jresult;
55258 }
55259
55260
55261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55262   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55263   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55264
55265   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55266   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55267   {
55268     try {
55269       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55270     } catch (std::out_of_range& e) {
55271       {
55272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55273       };
55274     } catch (std::exception& e) {
55275       {
55276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55277       };
55278     } catch (Dali::DaliException e) {
55279       {
55280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55281       };
55282     } catch (...) {
55283       {
55284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55285       };
55286     }
55287   }
55288
55289 }
55290
55291
55292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55293   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55294   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55295
55296   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55297   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55298   {
55299     try {
55300       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55301     } catch (std::out_of_range& e) {
55302       {
55303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55304       };
55305     } catch (std::exception& e) {
55306       {
55307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55308       };
55309     } catch (Dali::DaliException e) {
55310       {
55311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55312       };
55313     } catch (...) {
55314       {
55315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55316       };
55317     }
55318   }
55319
55320 }
55321
55322
55323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55324   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55325   Dali::Actor arg2 ;
55326   Dali::LongPressGesture *arg3 = 0 ;
55327   Dali::Actor *argp2 ;
55328
55329   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55330   argp2 = (Dali::Actor *)jarg2;
55331   if (!argp2) {
55332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55333     return ;
55334   }
55335   arg2 = *argp2;
55336   arg3 = (Dali::LongPressGesture *)jarg3;
55337   if (!arg3) {
55338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55339     return ;
55340   }
55341   {
55342     try {
55343       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55344     } catch (std::out_of_range& e) {
55345       {
55346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55347       };
55348     } catch (std::exception& e) {
55349       {
55350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55351       };
55352     } catch (Dali::DaliException e) {
55353       {
55354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55355       };
55356     } catch (...) {
55357       {
55358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55359       };
55360     }
55361   }
55362
55363 }
55364
55365
55366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55367   void * jresult ;
55368   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55369
55370   {
55371     try {
55372       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55373     } catch (std::out_of_range& e) {
55374       {
55375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55376       };
55377     } catch (std::exception& e) {
55378       {
55379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55380       };
55381     } catch (Dali::DaliException e) {
55382       {
55383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55384       };
55385     } catch (...) {
55386       {
55387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55388       };
55389     }
55390   }
55391
55392   jresult = (void *)result;
55393   return jresult;
55394 }
55395
55396
55397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55398   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55399
55400   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55401   {
55402     try {
55403       delete arg1;
55404     } catch (std::out_of_range& e) {
55405       {
55406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55407       };
55408     } catch (std::exception& e) {
55409       {
55410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55411       };
55412     } catch (Dali::DaliException e) {
55413       {
55414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55415       };
55416     } catch (...) {
55417       {
55418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55419       };
55420     }
55421   }
55422
55423 }
55424
55425
55426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55427   unsigned int jresult ;
55428   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55429   bool result;
55430
55431   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55432   {
55433     try {
55434       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);
55435     } catch (std::out_of_range& e) {
55436       {
55437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55438       };
55439     } catch (std::exception& e) {
55440       {
55441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55442       };
55443     } catch (Dali::DaliException e) {
55444       {
55445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55446       };
55447     } catch (...) {
55448       {
55449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55450       };
55451     }
55452   }
55453
55454   jresult = result;
55455   return jresult;
55456 }
55457
55458
55459 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55460   unsigned long jresult ;
55461   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55462   std::size_t result;
55463
55464   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55465   {
55466     try {
55467       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);
55468     } catch (std::out_of_range& e) {
55469       {
55470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55471       };
55472     } catch (std::exception& e) {
55473       {
55474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55475       };
55476     } catch (Dali::DaliException e) {
55477       {
55478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55479       };
55480     } catch (...) {
55481       {
55482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55483       };
55484     }
55485   }
55486
55487   jresult = (unsigned long)result;
55488   return jresult;
55489 }
55490
55491
55492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55493   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55494   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55495
55496   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55497   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55498   {
55499     try {
55500       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55501     } catch (std::out_of_range& e) {
55502       {
55503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55504       };
55505     } catch (std::exception& e) {
55506       {
55507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55508       };
55509     } catch (Dali::DaliException e) {
55510       {
55511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55512       };
55513     } catch (...) {
55514       {
55515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55516       };
55517     }
55518   }
55519
55520 }
55521
55522
55523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55524   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55525   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55526
55527   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55528   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55529   {
55530     try {
55531       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55532     } catch (std::out_of_range& e) {
55533       {
55534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55535       };
55536     } catch (std::exception& e) {
55537       {
55538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55539       };
55540     } catch (Dali::DaliException e) {
55541       {
55542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55543       };
55544     } catch (...) {
55545       {
55546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55547       };
55548     }
55549   }
55550
55551 }
55552
55553
55554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55555   unsigned int jresult ;
55556   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55557   Dali::Actor arg2 ;
55558   Dali::TouchData *arg3 = 0 ;
55559   Dali::Actor *argp2 ;
55560   bool result;
55561
55562   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55563   argp2 = (Dali::Actor *)jarg2;
55564   if (!argp2) {
55565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55566     return 0;
55567   }
55568   arg2 = *argp2;
55569   arg3 = (Dali::TouchData *)jarg3;
55570   if (!arg3) {
55571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55572     return 0;
55573   }
55574   {
55575     try {
55576       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55577     } catch (std::out_of_range& e) {
55578       {
55579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55580       };
55581     } catch (std::exception& e) {
55582       {
55583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55584       };
55585     } catch (Dali::DaliException e) {
55586       {
55587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55588       };
55589     } catch (...) {
55590       {
55591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55592       };
55593     }
55594   }
55595
55596   jresult = result;
55597   return jresult;
55598 }
55599
55600
55601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55602   void * jresult ;
55603   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55604
55605   {
55606     try {
55607       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55608     } catch (std::out_of_range& e) {
55609       {
55610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55611       };
55612     } catch (std::exception& e) {
55613       {
55614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55615       };
55616     } catch (Dali::DaliException e) {
55617       {
55618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55619       };
55620     } catch (...) {
55621       {
55622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55623       };
55624     }
55625   }
55626
55627   jresult = (void *)result;
55628   return jresult;
55629 }
55630
55631
55632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55633   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55634
55635   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55636   {
55637     try {
55638       delete arg1;
55639     } catch (std::out_of_range& e) {
55640       {
55641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55642       };
55643     } catch (std::exception& e) {
55644       {
55645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55646       };
55647     } catch (Dali::DaliException e) {
55648       {
55649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55650       };
55651     } catch (...) {
55652       {
55653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55654       };
55655     }
55656   }
55657
55658 }
55659
55660
55661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55662   unsigned int jresult ;
55663   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55664   bool result;
55665
55666   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55667   {
55668     try {
55669       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);
55670     } catch (std::out_of_range& e) {
55671       {
55672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55673       };
55674     } catch (std::exception& e) {
55675       {
55676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55677       };
55678     } catch (Dali::DaliException e) {
55679       {
55680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55681       };
55682     } catch (...) {
55683       {
55684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55685       };
55686     }
55687   }
55688
55689   jresult = result;
55690   return jresult;
55691 }
55692
55693
55694 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55695   unsigned long jresult ;
55696   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55697   std::size_t result;
55698
55699   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55700   {
55701     try {
55702       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);
55703     } catch (std::out_of_range& e) {
55704       {
55705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55706       };
55707     } catch (std::exception& e) {
55708       {
55709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55710       };
55711     } catch (Dali::DaliException e) {
55712       {
55713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55714       };
55715     } catch (...) {
55716       {
55717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55718       };
55719     }
55720   }
55721
55722   jresult = (unsigned long)result;
55723   return jresult;
55724 }
55725
55726
55727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55728   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55729   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55730
55731   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55732   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55733   {
55734     try {
55735       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55736     } catch (std::out_of_range& e) {
55737       {
55738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55739       };
55740     } catch (std::exception& e) {
55741       {
55742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55743       };
55744     } catch (Dali::DaliException e) {
55745       {
55746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55747       };
55748     } catch (...) {
55749       {
55750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55751       };
55752     }
55753   }
55754
55755 }
55756
55757
55758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55759   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55760   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55761
55762   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55763   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55764   {
55765     try {
55766       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55767     } catch (std::out_of_range& e) {
55768       {
55769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55770       };
55771     } catch (std::exception& e) {
55772       {
55773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55774       };
55775     } catch (Dali::DaliException e) {
55776       {
55777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55778       };
55779     } catch (...) {
55780       {
55781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55782       };
55783     }
55784   }
55785
55786 }
55787
55788
55789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55790   unsigned int jresult ;
55791   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55792   Dali::Actor arg2 ;
55793   Dali::HoverEvent *arg3 = 0 ;
55794   Dali::Actor *argp2 ;
55795   bool result;
55796
55797   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55798   argp2 = (Dali::Actor *)jarg2;
55799   if (!argp2) {
55800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55801     return 0;
55802   }
55803   arg2 = *argp2;
55804   arg3 = (Dali::HoverEvent *)jarg3;
55805   if (!arg3) {
55806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55807     return 0;
55808   }
55809   {
55810     try {
55811       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55812     } catch (std::out_of_range& e) {
55813       {
55814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55815       };
55816     } catch (std::exception& e) {
55817       {
55818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55819       };
55820     } catch (Dali::DaliException e) {
55821       {
55822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55823       };
55824     } catch (...) {
55825       {
55826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55827       };
55828     }
55829   }
55830
55831   jresult = result;
55832   return jresult;
55833 }
55834
55835
55836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55837   void * jresult ;
55838   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55839
55840   {
55841     try {
55842       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55843     } catch (std::out_of_range& e) {
55844       {
55845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55846       };
55847     } catch (std::exception& e) {
55848       {
55849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55850       };
55851     } catch (Dali::DaliException e) {
55852       {
55853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55854       };
55855     } catch (...) {
55856       {
55857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55858       };
55859     }
55860   }
55861
55862   jresult = (void *)result;
55863   return jresult;
55864 }
55865
55866
55867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55868   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55869
55870   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55871   {
55872     try {
55873       delete arg1;
55874     } catch (std::out_of_range& e) {
55875       {
55876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55877       };
55878     } catch (std::exception& e) {
55879       {
55880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55881       };
55882     } catch (Dali::DaliException e) {
55883       {
55884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55885       };
55886     } catch (...) {
55887       {
55888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55889       };
55890     }
55891   }
55892
55893 }
55894
55895
55896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55897   unsigned int jresult ;
55898   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55899   bool result;
55900
55901   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55902   {
55903     try {
55904       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);
55905     } catch (std::out_of_range& e) {
55906       {
55907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55908       };
55909     } catch (std::exception& e) {
55910       {
55911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55912       };
55913     } catch (Dali::DaliException e) {
55914       {
55915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55916       };
55917     } catch (...) {
55918       {
55919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55920       };
55921     }
55922   }
55923
55924   jresult = result;
55925   return jresult;
55926 }
55927
55928
55929 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55930   unsigned long jresult ;
55931   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55932   std::size_t result;
55933
55934   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55935   {
55936     try {
55937       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);
55938     } catch (std::out_of_range& e) {
55939       {
55940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55941       };
55942     } catch (std::exception& e) {
55943       {
55944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55945       };
55946     } catch (Dali::DaliException e) {
55947       {
55948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55949       };
55950     } catch (...) {
55951       {
55952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55953       };
55954     }
55955   }
55956
55957   jresult = (unsigned long)result;
55958   return jresult;
55959 }
55960
55961
55962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55963   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55964   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55965
55966   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55967   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55968   {
55969     try {
55970       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55971     } catch (std::out_of_range& e) {
55972       {
55973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55974       };
55975     } catch (std::exception& e) {
55976       {
55977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55978       };
55979     } catch (Dali::DaliException e) {
55980       {
55981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55982       };
55983     } catch (...) {
55984       {
55985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55986       };
55987     }
55988   }
55989
55990 }
55991
55992
55993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55994   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55995   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55996
55997   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55998   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55999   {
56000     try {
56001       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56002     } catch (std::out_of_range& e) {
56003       {
56004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56005       };
56006     } catch (std::exception& e) {
56007       {
56008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56009       };
56010     } catch (Dali::DaliException e) {
56011       {
56012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56013       };
56014     } catch (...) {
56015       {
56016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56017       };
56018     }
56019   }
56020
56021 }
56022
56023
56024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
56025   unsigned int jresult ;
56026   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
56027   Dali::Actor arg2 ;
56028   Dali::WheelEvent *arg3 = 0 ;
56029   Dali::Actor *argp2 ;
56030   bool result;
56031
56032   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
56033   argp2 = (Dali::Actor *)jarg2;
56034   if (!argp2) {
56035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56036     return 0;
56037   }
56038   arg2 = *argp2;
56039   arg3 = (Dali::WheelEvent *)jarg3;
56040   if (!arg3) {
56041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56042     return 0;
56043   }
56044   {
56045     try {
56046       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
56047     } catch (std::out_of_range& e) {
56048       {
56049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56050       };
56051     } catch (std::exception& e) {
56052       {
56053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56054       };
56055     } catch (Dali::DaliException e) {
56056       {
56057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56058       };
56059     } catch (...) {
56060       {
56061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56062       };
56063     }
56064   }
56065
56066   jresult = result;
56067   return jresult;
56068 }
56069
56070
56071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
56072   void * jresult ;
56073   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
56074
56075   {
56076     try {
56077       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
56078     } catch (std::out_of_range& e) {
56079       {
56080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56081       };
56082     } catch (std::exception& e) {
56083       {
56084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56085       };
56086     } catch (Dali::DaliException e) {
56087       {
56088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56089       };
56090     } catch (...) {
56091       {
56092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56093       };
56094     }
56095   }
56096
56097   jresult = (void *)result;
56098   return jresult;
56099 }
56100
56101
56102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
56103   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
56104
56105   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
56106   {
56107     try {
56108       delete arg1;
56109     } catch (std::out_of_range& e) {
56110       {
56111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56112       };
56113     } catch (std::exception& e) {
56114       {
56115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56116       };
56117     } catch (Dali::DaliException e) {
56118       {
56119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56120       };
56121     } catch (...) {
56122       {
56123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56124       };
56125     }
56126   }
56127
56128 }
56129
56130
56131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
56132   unsigned int jresult ;
56133   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56134   bool result;
56135
56136   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56137   {
56138     try {
56139       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
56140     } catch (std::out_of_range& e) {
56141       {
56142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56143       };
56144     } catch (std::exception& e) {
56145       {
56146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56147       };
56148     } catch (Dali::DaliException e) {
56149       {
56150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56151       };
56152     } catch (...) {
56153       {
56154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56155       };
56156     }
56157   }
56158
56159   jresult = result;
56160   return jresult;
56161 }
56162
56163
56164 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
56165   unsigned long jresult ;
56166   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56167   std::size_t result;
56168
56169   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56170   {
56171     try {
56172       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56173     } catch (std::out_of_range& e) {
56174       {
56175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56176       };
56177     } catch (std::exception& e) {
56178       {
56179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56180       };
56181     } catch (Dali::DaliException e) {
56182       {
56183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56184       };
56185     } catch (...) {
56186       {
56187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56188       };
56189     }
56190   }
56191
56192   jresult = (unsigned long)result;
56193   return jresult;
56194 }
56195
56196
56197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56198   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56199   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56200
56201   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56202   arg2 = (void (*)(Dali::Actor))jarg2;
56203   {
56204     try {
56205       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56206     } catch (std::out_of_range& e) {
56207       {
56208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56209       };
56210     } catch (std::exception& e) {
56211       {
56212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56213       };
56214     } catch (Dali::DaliException e) {
56215       {
56216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56217       };
56218     } catch (...) {
56219       {
56220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56221       };
56222     }
56223   }
56224
56225 }
56226
56227
56228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56229   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56230   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56231
56232   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56233   arg2 = (void (*)(Dali::Actor))jarg2;
56234   {
56235     try {
56236       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56237     } catch (std::out_of_range& e) {
56238       {
56239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56240       };
56241     } catch (std::exception& e) {
56242       {
56243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56244       };
56245     } catch (Dali::DaliException e) {
56246       {
56247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56248       };
56249     } catch (...) {
56250       {
56251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56252       };
56253     }
56254   }
56255
56256 }
56257
56258
56259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56260   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56261   Dali::Actor arg2 ;
56262   Dali::Actor *argp2 ;
56263
56264   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56265   argp2 = (Dali::Actor *)jarg2;
56266   if (!argp2) {
56267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56268     return ;
56269   }
56270   arg2 = *argp2;
56271   {
56272     try {
56273       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56274     } catch (std::out_of_range& e) {
56275       {
56276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56277       };
56278     } catch (std::exception& e) {
56279       {
56280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56281       };
56282     } catch (Dali::DaliException e) {
56283       {
56284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56285       };
56286     } catch (...) {
56287       {
56288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56289       };
56290     }
56291   }
56292
56293 }
56294
56295
56296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56297   void * jresult ;
56298   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56299
56300   {
56301     try {
56302       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56303     } catch (std::out_of_range& e) {
56304       {
56305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56306       };
56307     } catch (std::exception& e) {
56308       {
56309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56310       };
56311     } catch (Dali::DaliException e) {
56312       {
56313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56314       };
56315     } catch (...) {
56316       {
56317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56318       };
56319     }
56320   }
56321
56322   jresult = (void *)result;
56323   return jresult;
56324 }
56325
56326
56327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56328   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56329
56330   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56331   {
56332     try {
56333       delete arg1;
56334     } catch (std::out_of_range& e) {
56335       {
56336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56337       };
56338     } catch (std::exception& e) {
56339       {
56340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56341       };
56342     } catch (Dali::DaliException e) {
56343       {
56344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56345       };
56346     } catch (...) {
56347       {
56348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56349       };
56350     }
56351   }
56352
56353 }
56354
56355
56356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56357   unsigned int jresult ;
56358   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56359   bool result;
56360
56361   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56362   {
56363     try {
56364       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56365     } catch (std::out_of_range& e) {
56366       {
56367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56368       };
56369     } catch (std::exception& e) {
56370       {
56371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56372       };
56373     } catch (Dali::DaliException e) {
56374       {
56375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56376       };
56377     } catch (...) {
56378       {
56379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56380       };
56381     }
56382   }
56383
56384   jresult = result;
56385   return jresult;
56386 }
56387
56388
56389 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56390   unsigned long jresult ;
56391   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56392   std::size_t result;
56393
56394   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56395   {
56396     try {
56397       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56398     } catch (std::out_of_range& e) {
56399       {
56400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56401       };
56402     } catch (std::exception& e) {
56403       {
56404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56405       };
56406     } catch (Dali::DaliException e) {
56407       {
56408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56409       };
56410     } catch (...) {
56411       {
56412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56413       };
56414     }
56415   }
56416
56417   jresult = (unsigned long)result;
56418   return jresult;
56419 }
56420
56421
56422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56423   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56424   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56425
56426   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56427   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56428   {
56429     try {
56430       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56431     } catch (std::out_of_range& e) {
56432       {
56433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56434       };
56435     } catch (std::exception& e) {
56436       {
56437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56438       };
56439     } catch (Dali::DaliException e) {
56440       {
56441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56442       };
56443     } catch (...) {
56444       {
56445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56446       };
56447     }
56448   }
56449
56450 }
56451
56452
56453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56454   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56455   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56456
56457   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56458   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56459   {
56460     try {
56461       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56462     } catch (std::out_of_range& e) {
56463       {
56464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56465       };
56466     } catch (std::exception& e) {
56467       {
56468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56469       };
56470     } catch (Dali::DaliException e) {
56471       {
56472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56473       };
56474     } catch (...) {
56475       {
56476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56477       };
56478     }
56479   }
56480
56481 }
56482
56483
56484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56485   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56486   Dali::KeyEvent *arg2 = 0 ;
56487
56488   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56489   arg2 = (Dali::KeyEvent *)jarg2;
56490   if (!arg2) {
56491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56492     return ;
56493   }
56494   {
56495     try {
56496       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56497     } catch (std::out_of_range& e) {
56498       {
56499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56500       };
56501     } catch (std::exception& e) {
56502       {
56503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56504       };
56505     } catch (Dali::DaliException e) {
56506       {
56507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56508       };
56509     } catch (...) {
56510       {
56511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56512       };
56513     }
56514   }
56515
56516 }
56517
56518
56519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56520   void * jresult ;
56521   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56522
56523   {
56524     try {
56525       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56526     } catch (std::out_of_range& e) {
56527       {
56528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56529       };
56530     } catch (std::exception& e) {
56531       {
56532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56533       };
56534     } catch (Dali::DaliException e) {
56535       {
56536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56537       };
56538     } catch (...) {
56539       {
56540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56541       };
56542     }
56543   }
56544
56545   jresult = (void *)result;
56546   return jresult;
56547 }
56548
56549
56550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56551   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56552
56553   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56554   {
56555     try {
56556       delete arg1;
56557     } catch (std::out_of_range& e) {
56558       {
56559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56560       };
56561     } catch (std::exception& e) {
56562       {
56563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56564       };
56565     } catch (Dali::DaliException e) {
56566       {
56567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56568       };
56569     } catch (...) {
56570       {
56571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56572       };
56573     }
56574   }
56575
56576 }
56577
56578
56579 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56580   unsigned int jresult ;
56581   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56582   bool result;
56583
56584   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56585   {
56586     try {
56587       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56588     } catch (std::out_of_range& e) {
56589       {
56590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56591       };
56592     } catch (std::exception& e) {
56593       {
56594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56595       };
56596     } catch (Dali::DaliException e) {
56597       {
56598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56599       };
56600     } catch (...) {
56601       {
56602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56603       };
56604     }
56605   }
56606
56607   jresult = result;
56608   return jresult;
56609 }
56610
56611
56612 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56613   unsigned long jresult ;
56614   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56615   std::size_t result;
56616
56617   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56618   {
56619     try {
56620       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56621     } catch (std::out_of_range& e) {
56622       {
56623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56624       };
56625     } catch (std::exception& e) {
56626       {
56627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56628       };
56629     } catch (Dali::DaliException e) {
56630       {
56631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56632       };
56633     } catch (...) {
56634       {
56635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56636       };
56637     }
56638   }
56639
56640   jresult = (unsigned long)result;
56641   return jresult;
56642 }
56643
56644
56645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56646   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56647   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56648
56649   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56650   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56651   {
56652     try {
56653       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56654     } catch (std::out_of_range& e) {
56655       {
56656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56657       };
56658     } catch (std::exception& e) {
56659       {
56660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56661       };
56662     } catch (Dali::DaliException e) {
56663       {
56664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56665       };
56666     } catch (...) {
56667       {
56668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56669       };
56670     }
56671   }
56672
56673 }
56674
56675
56676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56677   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56678   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56679
56680   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56681   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56682   {
56683     try {
56684       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56685     } catch (std::out_of_range& e) {
56686       {
56687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56688       };
56689     } catch (std::exception& e) {
56690       {
56691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56692       };
56693     } catch (Dali::DaliException e) {
56694       {
56695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56696       };
56697     } catch (...) {
56698       {
56699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56700       };
56701     }
56702   }
56703
56704 }
56705
56706
56707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56708   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56709   Dali::TouchData *arg2 = 0 ;
56710
56711   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56712   arg2 = (Dali::TouchData *)jarg2;
56713   if (!arg2) {
56714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56715     return ;
56716   }
56717   {
56718     try {
56719       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56720     } catch (std::out_of_range& e) {
56721       {
56722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56723       };
56724     } catch (std::exception& e) {
56725       {
56726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56727       };
56728     } catch (Dali::DaliException e) {
56729       {
56730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56731       };
56732     } catch (...) {
56733       {
56734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56735       };
56736     }
56737   }
56738
56739 }
56740
56741
56742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56743   void * jresult ;
56744   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56745
56746   {
56747     try {
56748       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56749     } catch (std::out_of_range& e) {
56750       {
56751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56752       };
56753     } catch (std::exception& e) {
56754       {
56755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56756       };
56757     } catch (Dali::DaliException e) {
56758       {
56759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56760       };
56761     } catch (...) {
56762       {
56763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56764       };
56765     }
56766   }
56767
56768   jresult = (void *)result;
56769   return jresult;
56770 }
56771
56772
56773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56774   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56775
56776   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56777   {
56778     try {
56779       delete arg1;
56780     } catch (std::out_of_range& e) {
56781       {
56782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56783       };
56784     } catch (std::exception& e) {
56785       {
56786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56787       };
56788     } catch (Dali::DaliException e) {
56789       {
56790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56791       };
56792     } catch (...) {
56793       {
56794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56795       };
56796     }
56797   }
56798
56799 }
56800
56801
56802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56803   unsigned int jresult ;
56804   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56805   bool result;
56806
56807   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56808   {
56809     try {
56810       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56811     } catch (std::out_of_range& e) {
56812       {
56813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56814       };
56815     } catch (std::exception& e) {
56816       {
56817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56818       };
56819     } catch (Dali::DaliException e) {
56820       {
56821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56822       };
56823     } catch (...) {
56824       {
56825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56826       };
56827     }
56828   }
56829
56830   jresult = result;
56831   return jresult;
56832 }
56833
56834
56835 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56836   unsigned long jresult ;
56837   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56838   std::size_t result;
56839
56840   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56841   {
56842     try {
56843       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56844     } catch (std::out_of_range& e) {
56845       {
56846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56847       };
56848     } catch (std::exception& e) {
56849       {
56850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56851       };
56852     } catch (Dali::DaliException e) {
56853       {
56854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56855       };
56856     } catch (...) {
56857       {
56858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56859       };
56860     }
56861   }
56862
56863   jresult = (unsigned long)result;
56864   return jresult;
56865 }
56866
56867
56868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56869   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56870   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56871
56872   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56873   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56874   {
56875     try {
56876       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56877     } catch (std::out_of_range& e) {
56878       {
56879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56880       };
56881     } catch (std::exception& e) {
56882       {
56883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56884       };
56885     } catch (Dali::DaliException e) {
56886       {
56887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56888       };
56889     } catch (...) {
56890       {
56891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56892       };
56893     }
56894   }
56895
56896 }
56897
56898
56899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56900   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56901   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56902
56903   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56904   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56905   {
56906     try {
56907       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56908     } catch (std::out_of_range& e) {
56909       {
56910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56911       };
56912     } catch (std::exception& e) {
56913       {
56914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56915       };
56916     } catch (Dali::DaliException e) {
56917       {
56918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56919       };
56920     } catch (...) {
56921       {
56922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56923       };
56924     }
56925   }
56926
56927 }
56928
56929
56930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56931   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56932   Dali::WheelEvent *arg2 = 0 ;
56933
56934   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56935   arg2 = (Dali::WheelEvent *)jarg2;
56936   if (!arg2) {
56937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56938     return ;
56939   }
56940   {
56941     try {
56942       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56943     } catch (std::out_of_range& e) {
56944       {
56945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56946       };
56947     } catch (std::exception& e) {
56948       {
56949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56950       };
56951     } catch (Dali::DaliException e) {
56952       {
56953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56954       };
56955     } catch (...) {
56956       {
56957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56958       };
56959     }
56960   }
56961
56962 }
56963
56964
56965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56966   void * jresult ;
56967   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56968
56969   {
56970     try {
56971       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56972     } catch (std::out_of_range& e) {
56973       {
56974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56975       };
56976     } catch (std::exception& e) {
56977       {
56978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56979       };
56980     } catch (Dali::DaliException e) {
56981       {
56982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56983       };
56984     } catch (...) {
56985       {
56986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56987       };
56988     }
56989   }
56990
56991   jresult = (void *)result;
56992   return jresult;
56993 }
56994
56995
56996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56997   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56998
56999   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
57000   {
57001     try {
57002       delete arg1;
57003     } catch (std::out_of_range& e) {
57004       {
57005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57006       };
57007     } catch (std::exception& e) {
57008       {
57009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57010       };
57011     } catch (Dali::DaliException e) {
57012       {
57013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57014       };
57015     } catch (...) {
57016       {
57017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57018       };
57019     }
57020   }
57021
57022 }
57023
57024
57025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
57026   void * jresult ;
57027   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
57028
57029   {
57030     try {
57031       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
57032     } catch (std::out_of_range& e) {
57033       {
57034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57035       };
57036     } catch (std::exception& e) {
57037       {
57038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57039       };
57040     } catch (Dali::DaliException e) {
57041       {
57042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57043       };
57044     } catch (...) {
57045       {
57046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57047       };
57048     }
57049   }
57050
57051   jresult = (void *)result;
57052   return jresult;
57053 }
57054
57055
57056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
57057   void * jresult ;
57058   Dali::Radian arg1 ;
57059   Dali::Radian arg2 ;
57060   Dali::Radian *argp1 ;
57061   Dali::Radian *argp2 ;
57062   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
57063
57064   argp1 = (Dali::Radian *)jarg1;
57065   if (!argp1) {
57066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
57067     return 0;
57068   }
57069   arg1 = *argp1;
57070   argp2 = (Dali::Radian *)jarg2;
57071   if (!argp2) {
57072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
57073     return 0;
57074   }
57075   arg2 = *argp2;
57076   {
57077     try {
57078       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
57079     } catch (std::out_of_range& e) {
57080       {
57081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57082       };
57083     } catch (std::exception& e) {
57084       {
57085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57086       };
57087     } catch (Dali::DaliException e) {
57088       {
57089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57090       };
57091     } catch (...) {
57092       {
57093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57094       };
57095     }
57096   }
57097
57098   jresult = (void *)result;
57099   return jresult;
57100 }
57101
57102
57103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
57104   void * jresult ;
57105   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
57106   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
57107
57108   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57109   if (!arg1) {
57110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
57111     return 0;
57112   }
57113   {
57114     try {
57115       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
57116     } catch (std::out_of_range& e) {
57117       {
57118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57119       };
57120     } catch (std::exception& e) {
57121       {
57122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57123       };
57124     } catch (Dali::DaliException e) {
57125       {
57126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57127       };
57128     } catch (...) {
57129       {
57130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57131       };
57132     }
57133   }
57134
57135   jresult = (void *)result;
57136   return jresult;
57137 }
57138
57139
57140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
57141   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57142   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57143
57144   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57145   arg2 = (Dali::Radian *)jarg2;
57146   if (arg1) (arg1)->first = *arg2;
57147 }
57148
57149
57150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
57151   void * jresult ;
57152   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57153   Dali::Radian *result = 0 ;
57154
57155   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57156   result = (Dali::Radian *)& ((arg1)->first);
57157   jresult = (void *)result;
57158   return jresult;
57159 }
57160
57161
57162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
57163   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57164   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57165
57166   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57167   arg2 = (Dali::Radian *)jarg2;
57168   if (arg1) (arg1)->second = *arg2;
57169 }
57170
57171
57172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57173   void * jresult ;
57174   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57175   Dali::Radian *result = 0 ;
57176
57177   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57178   result = (Dali::Radian *)& ((arg1)->second);
57179   jresult = (void *)result;
57180   return jresult;
57181 }
57182
57183
57184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57185   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57186
57187   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57188   {
57189     try {
57190       delete arg1;
57191     } catch (std::out_of_range& e) {
57192       {
57193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57194       };
57195     } catch (std::exception& e) {
57196       {
57197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57198       };
57199     } catch (Dali::DaliException e) {
57200       {
57201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57202       };
57203     } catch (...) {
57204       {
57205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57206       };
57207     }
57208   }
57209
57210 }
57211
57212
57213 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57214   unsigned int jresult ;
57215   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57216   bool result;
57217
57218   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57219   {
57220     try {
57221       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);
57222     } catch (std::out_of_range& e) {
57223       {
57224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57225       };
57226     } catch (std::exception& e) {
57227       {
57228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57229       };
57230     } catch (Dali::DaliException e) {
57231       {
57232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57233       };
57234     } catch (...) {
57235       {
57236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57237       };
57238     }
57239   }
57240
57241   jresult = result;
57242   return jresult;
57243 }
57244
57245
57246 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57247   unsigned long jresult ;
57248   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57249   std::size_t result;
57250
57251   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57252   {
57253     try {
57254       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);
57255     } catch (std::out_of_range& e) {
57256       {
57257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57258       };
57259     } catch (std::exception& e) {
57260       {
57261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57262       };
57263     } catch (Dali::DaliException e) {
57264       {
57265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57266       };
57267     } catch (...) {
57268       {
57269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57270       };
57271     }
57272   }
57273
57274   jresult = (unsigned long)result;
57275   return jresult;
57276 }
57277
57278
57279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57280   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57281   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57282
57283   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57284   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57285   {
57286     try {
57287       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57288     } catch (std::out_of_range& e) {
57289       {
57290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57291       };
57292     } catch (std::exception& e) {
57293       {
57294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57295       };
57296     } catch (Dali::DaliException e) {
57297       {
57298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57299       };
57300     } catch (...) {
57301       {
57302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57303       };
57304     }
57305   }
57306
57307 }
57308
57309
57310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57311   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57312   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57313
57314   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57315   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57316   {
57317     try {
57318       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57319     } catch (std::out_of_range& e) {
57320       {
57321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57322       };
57323     } catch (std::exception& e) {
57324       {
57325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57326       };
57327     } catch (Dali::DaliException e) {
57328       {
57329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57330       };
57331     } catch (...) {
57332       {
57333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57334       };
57335     }
57336   }
57337
57338 }
57339
57340
57341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57342   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57343   Dali::Actor arg2 ;
57344   Dali::PanGesture *arg3 = 0 ;
57345   Dali::Actor *argp2 ;
57346
57347   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57348   argp2 = (Dali::Actor *)jarg2;
57349   if (!argp2) {
57350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57351     return ;
57352   }
57353   arg2 = *argp2;
57354   arg3 = (Dali::PanGesture *)jarg3;
57355   if (!arg3) {
57356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57357     return ;
57358   }
57359   {
57360     try {
57361       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57362     } catch (std::out_of_range& e) {
57363       {
57364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57365       };
57366     } catch (std::exception& e) {
57367       {
57368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57369       };
57370     } catch (Dali::DaliException e) {
57371       {
57372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57373       };
57374     } catch (...) {
57375       {
57376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57377       };
57378     }
57379   }
57380
57381 }
57382
57383
57384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57385   void * jresult ;
57386   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57387
57388   {
57389     try {
57390       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57391     } catch (std::out_of_range& e) {
57392       {
57393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57394       };
57395     } catch (std::exception& e) {
57396       {
57397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57398       };
57399     } catch (Dali::DaliException e) {
57400       {
57401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57402       };
57403     } catch (...) {
57404       {
57405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57406       };
57407     }
57408   }
57409
57410   jresult = (void *)result;
57411   return jresult;
57412 }
57413
57414
57415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57416   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57417
57418   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57419   {
57420     try {
57421       delete arg1;
57422     } catch (std::out_of_range& e) {
57423       {
57424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57425       };
57426     } catch (std::exception& e) {
57427       {
57428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57429       };
57430     } catch (Dali::DaliException e) {
57431       {
57432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57433       };
57434     } catch (...) {
57435       {
57436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57437       };
57438     }
57439   }
57440
57441 }
57442
57443
57444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57445   unsigned int jresult ;
57446   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57447   bool result;
57448
57449   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57450   {
57451     try {
57452       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);
57453     } catch (std::out_of_range& e) {
57454       {
57455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57456       };
57457     } catch (std::exception& e) {
57458       {
57459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57460       };
57461     } catch (Dali::DaliException e) {
57462       {
57463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57464       };
57465     } catch (...) {
57466       {
57467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57468       };
57469     }
57470   }
57471
57472   jresult = result;
57473   return jresult;
57474 }
57475
57476
57477 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57478   unsigned long jresult ;
57479   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57480   std::size_t result;
57481
57482   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57483   {
57484     try {
57485       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);
57486     } catch (std::out_of_range& e) {
57487       {
57488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57489       };
57490     } catch (std::exception& e) {
57491       {
57492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57493       };
57494     } catch (Dali::DaliException e) {
57495       {
57496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57497       };
57498     } catch (...) {
57499       {
57500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57501       };
57502     }
57503   }
57504
57505   jresult = (unsigned long)result;
57506   return jresult;
57507 }
57508
57509
57510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57511   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57512   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57513
57514   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57515   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57516   {
57517     try {
57518       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57519     } catch (std::out_of_range& e) {
57520       {
57521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57522       };
57523     } catch (std::exception& e) {
57524       {
57525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57526       };
57527     } catch (Dali::DaliException e) {
57528       {
57529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57530       };
57531     } catch (...) {
57532       {
57533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57534       };
57535     }
57536   }
57537
57538 }
57539
57540
57541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57542   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57543   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57544
57545   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57546   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57547   {
57548     try {
57549       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57550     } catch (std::out_of_range& e) {
57551       {
57552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57553       };
57554     } catch (std::exception& e) {
57555       {
57556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57557       };
57558     } catch (Dali::DaliException e) {
57559       {
57560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57561       };
57562     } catch (...) {
57563       {
57564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57565       };
57566     }
57567   }
57568
57569 }
57570
57571
57572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57573   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57574   Dali::Actor arg2 ;
57575   Dali::PinchGesture *arg3 = 0 ;
57576   Dali::Actor *argp2 ;
57577
57578   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57579   argp2 = (Dali::Actor *)jarg2;
57580   if (!argp2) {
57581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57582     return ;
57583   }
57584   arg2 = *argp2;
57585   arg3 = (Dali::PinchGesture *)jarg3;
57586   if (!arg3) {
57587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57588     return ;
57589   }
57590   {
57591     try {
57592       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57593     } catch (std::out_of_range& e) {
57594       {
57595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57596       };
57597     } catch (std::exception& e) {
57598       {
57599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57600       };
57601     } catch (Dali::DaliException e) {
57602       {
57603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57604       };
57605     } catch (...) {
57606       {
57607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57608       };
57609     }
57610   }
57611
57612 }
57613
57614
57615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57616   void * jresult ;
57617   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57618
57619   {
57620     try {
57621       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57622     } catch (std::out_of_range& e) {
57623       {
57624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57625       };
57626     } catch (std::exception& e) {
57627       {
57628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57629       };
57630     } catch (Dali::DaliException e) {
57631       {
57632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57633       };
57634     } catch (...) {
57635       {
57636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57637       };
57638     }
57639   }
57640
57641   jresult = (void *)result;
57642   return jresult;
57643 }
57644
57645
57646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57647   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57648
57649   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57650   {
57651     try {
57652       delete arg1;
57653     } catch (std::out_of_range& e) {
57654       {
57655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57656       };
57657     } catch (std::exception& e) {
57658       {
57659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57660       };
57661     } catch (Dali::DaliException e) {
57662       {
57663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57664       };
57665     } catch (...) {
57666       {
57667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57668       };
57669     }
57670   }
57671
57672 }
57673
57674
57675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57676   unsigned int jresult ;
57677   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57678   bool result;
57679
57680   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57681   {
57682     try {
57683       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);
57684     } catch (std::out_of_range& e) {
57685       {
57686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57687       };
57688     } catch (std::exception& e) {
57689       {
57690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57691       };
57692     } catch (Dali::DaliException e) {
57693       {
57694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57695       };
57696     } catch (...) {
57697       {
57698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57699       };
57700     }
57701   }
57702
57703   jresult = result;
57704   return jresult;
57705 }
57706
57707
57708 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57709   unsigned long jresult ;
57710   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57711   std::size_t result;
57712
57713   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57714   {
57715     try {
57716       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);
57717     } catch (std::out_of_range& e) {
57718       {
57719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57720       };
57721     } catch (std::exception& e) {
57722       {
57723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57724       };
57725     } catch (Dali::DaliException e) {
57726       {
57727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57728       };
57729     } catch (...) {
57730       {
57731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57732       };
57733     }
57734   }
57735
57736   jresult = (unsigned long)result;
57737   return jresult;
57738 }
57739
57740
57741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57742   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57743   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57744
57745   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57746   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57747   {
57748     try {
57749       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57750     } catch (std::out_of_range& e) {
57751       {
57752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57753       };
57754     } catch (std::exception& e) {
57755       {
57756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57757       };
57758     } catch (Dali::DaliException e) {
57759       {
57760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57761       };
57762     } catch (...) {
57763       {
57764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57765       };
57766     }
57767   }
57768
57769 }
57770
57771
57772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57773   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57774   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57775
57776   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57777   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57778   {
57779     try {
57780       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57781     } catch (std::out_of_range& e) {
57782       {
57783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57784       };
57785     } catch (std::exception& e) {
57786       {
57787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57788       };
57789     } catch (Dali::DaliException e) {
57790       {
57791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57792       };
57793     } catch (...) {
57794       {
57795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57796       };
57797     }
57798   }
57799
57800 }
57801
57802
57803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57804   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57805   Dali::Actor arg2 ;
57806   Dali::TapGesture *arg3 = 0 ;
57807   Dali::Actor *argp2 ;
57808
57809   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57810   argp2 = (Dali::Actor *)jarg2;
57811   if (!argp2) {
57812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57813     return ;
57814   }
57815   arg2 = *argp2;
57816   arg3 = (Dali::TapGesture *)jarg3;
57817   if (!arg3) {
57818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57819     return ;
57820   }
57821   {
57822     try {
57823       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57824     } catch (std::out_of_range& e) {
57825       {
57826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57827       };
57828     } catch (std::exception& e) {
57829       {
57830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57831       };
57832     } catch (Dali::DaliException e) {
57833       {
57834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57835       };
57836     } catch (...) {
57837       {
57838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57839       };
57840     }
57841   }
57842
57843 }
57844
57845
57846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57847   void * jresult ;
57848   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57849
57850   {
57851     try {
57852       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57853     } catch (std::out_of_range& e) {
57854       {
57855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57856       };
57857     } catch (std::exception& e) {
57858       {
57859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57860       };
57861     } catch (Dali::DaliException e) {
57862       {
57863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57864       };
57865     } catch (...) {
57866       {
57867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57868       };
57869     }
57870   }
57871
57872   jresult = (void *)result;
57873   return jresult;
57874 }
57875
57876
57877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57878   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57879
57880   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57881   {
57882     try {
57883       delete arg1;
57884     } catch (std::out_of_range& e) {
57885       {
57886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57887       };
57888     } catch (std::exception& e) {
57889       {
57890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57891       };
57892     } catch (Dali::DaliException e) {
57893       {
57894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57895       };
57896     } catch (...) {
57897       {
57898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57899       };
57900     }
57901   }
57902
57903 }
57904
57905 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57906   unsigned int jresult ;
57907   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57908   bool result;
57909
57910   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57911   {
57912     try {
57913       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57914     } catch (std::out_of_range& e) {
57915       {
57916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57917       };
57918     } catch (std::exception& e) {
57919       {
57920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57921       };
57922     } catch (Dali::DaliException e) {
57923       {
57924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57925       };
57926     } catch (...) {
57927       {
57928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57929       };
57930     }
57931   }
57932
57933   jresult = result;
57934   return jresult;
57935 }
57936
57937
57938 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57939   unsigned long jresult ;
57940   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57941   std::size_t result;
57942
57943   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57944   {
57945     try {
57946       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57947     } catch (std::out_of_range& e) {
57948       {
57949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57950       };
57951     } catch (std::exception& e) {
57952       {
57953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57954       };
57955     } catch (Dali::DaliException e) {
57956       {
57957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57958       };
57959     } catch (...) {
57960       {
57961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57962       };
57963     }
57964   }
57965
57966   jresult = (unsigned long)result;
57967   return jresult;
57968 }
57969
57970
57971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57972   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57973   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57974
57975   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57976   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57977   {
57978     try {
57979       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57980     } catch (std::out_of_range& e) {
57981       {
57982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57983       };
57984     } catch (std::exception& e) {
57985       {
57986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57987       };
57988     } catch (Dali::DaliException e) {
57989       {
57990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57991       };
57992     } catch (...) {
57993       {
57994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57995       };
57996     }
57997   }
57998
57999 }
58000
58001
58002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
58003   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
58004   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
58005
58006   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
58007   arg2 = (void (*)(Dali::ResourceImage))jarg2;
58008   {
58009     try {
58010       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
58011     } catch (std::out_of_range& e) {
58012       {
58013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58014       };
58015     } catch (std::exception& e) {
58016       {
58017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58018       };
58019     } catch (Dali::DaliException e) {
58020       {
58021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58022       };
58023     } catch (...) {
58024       {
58025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58026       };
58027     }
58028   }
58029
58030 }
58031
58032
58033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
58034   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
58035   Dali::ResourceImage arg2 ;
58036   Dali::ResourceImage *argp2 ;
58037
58038   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
58039   argp2 = (Dali::ResourceImage *)jarg2;
58040   if (!argp2) {
58041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
58042     return ;
58043   }
58044   arg2 = *argp2;
58045   {
58046     try {
58047       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
58048     } catch (std::out_of_range& e) {
58049       {
58050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58051       };
58052     } catch (std::exception& e) {
58053       {
58054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58055       };
58056     } catch (Dali::DaliException e) {
58057       {
58058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58059       };
58060     } catch (...) {
58061       {
58062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58063       };
58064     }
58065   }
58066
58067 }
58068
58069
58070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
58071   void * jresult ;
58072   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
58073
58074   {
58075     try {
58076       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
58077     } catch (std::out_of_range& e) {
58078       {
58079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58080       };
58081     } catch (std::exception& e) {
58082       {
58083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58084       };
58085     } catch (Dali::DaliException e) {
58086       {
58087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58088       };
58089     } catch (...) {
58090       {
58091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58092       };
58093     }
58094   }
58095
58096   jresult = (void *)result;
58097   return jresult;
58098 }
58099
58100
58101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
58102   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
58103
58104   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
58105   {
58106     try {
58107       delete arg1;
58108     } catch (std::out_of_range& e) {
58109       {
58110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58111       };
58112     } catch (std::exception& e) {
58113       {
58114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58115       };
58116     } catch (Dali::DaliException e) {
58117       {
58118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58119       };
58120     } catch (...) {
58121       {
58122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58123       };
58124     }
58125   }
58126
58127 }
58128
58129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
58130   unsigned int jresult ;
58131   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58132   bool result = false;
58133
58134   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58135   {
58136     try {
58137       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);
58138     } catch (std::out_of_range& e) {
58139       {
58140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58141       };
58142     } catch (std::exception& e) {
58143       {
58144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58145       };
58146     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58147   }
58148   jresult = result;
58149   return jresult;
58150 }
58151
58152 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
58153   unsigned long jresult ;
58154   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58155   std::size_t result = 0;
58156
58157   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58158   {
58159     try {
58160       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);
58161     } catch (std::out_of_range& e) {
58162       {
58163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58164       };
58165     } catch (std::exception& e) {
58166       {
58167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58168       };
58169     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58170   }
58171   jresult = (unsigned long)result;
58172   return jresult;
58173 }
58174
58175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58176   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58177   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58178
58179   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58180   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58181   {
58182     try {
58183       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58184     } catch (std::out_of_range& e) {
58185       {
58186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58187       };
58188     } catch (std::exception& e) {
58189       {
58190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58191       };
58192     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58193   }
58194 }
58195
58196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58197   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58198   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58199
58200   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58201   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58202   {
58203     try {
58204       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58205     } catch (std::out_of_range& e) {
58206       {
58207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58208       };
58209     } catch (std::exception& e) {
58210       {
58211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58212       };
58213     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58214   }
58215 }
58216
58217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58218   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58219   Dali::Actor arg2 ;
58220   //bool arg3 ;
58221   Dali::LayoutDirection::Type arg4 ;
58222   Dali::Actor *argp2 ;
58223
58224   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58225   argp2 = (Dali::Actor *)jarg2;
58226   if (!argp2) {
58227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58228     return ;
58229   }
58230   arg2 = *argp2;
58231   //arg3 = jarg3 ? true : false;
58232   arg4 = (Dali::LayoutDirection::Type)jarg4;
58233   {
58234     try {
58235       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58236     } catch (std::out_of_range& e) {
58237       {
58238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58239       };
58240     } catch (std::exception& e) {
58241       {
58242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58243       };
58244     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58245   }
58246 }
58247
58248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58249   void * jresult ;
58250   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58251
58252   {
58253     try {
58254       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58255     } catch (std::out_of_range& e) {
58256       {
58257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58258       };
58259     } catch (std::exception& e) {
58260       {
58261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58262       };
58263     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58264   }
58265   jresult = (void *)result;
58266   return jresult;
58267 }
58268
58269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58270   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58271
58272   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58273   {
58274     try {
58275       delete arg1;
58276     } catch (std::out_of_range& e) {
58277       {
58278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58279       };
58280     } catch (std::exception& e) {
58281       {
58282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58283       };
58284     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58285   }
58286 }
58287
58288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58289   unsigned int jresult ;
58290   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58291   bool result;
58292
58293   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58294   {
58295     try {
58296       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);
58297     } catch (std::out_of_range& e) {
58298       {
58299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58300       };
58301     } catch (std::exception& e) {
58302       {
58303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58304       };
58305     } catch (Dali::DaliException e) {
58306       {
58307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58308       };
58309     } catch (...) {
58310       {
58311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58312       };
58313     }
58314   }
58315
58316   jresult = result;
58317   return jresult;
58318 }
58319
58320
58321 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58322   unsigned long jresult ;
58323   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58324   std::size_t result;
58325
58326   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58327   {
58328     try {
58329       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);
58330     } catch (std::out_of_range& e) {
58331       {
58332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58333       };
58334     } catch (std::exception& e) {
58335       {
58336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58337       };
58338     } catch (Dali::DaliException e) {
58339       {
58340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58341       };
58342     } catch (...) {
58343       {
58344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58345       };
58346     }
58347   }
58348
58349   jresult = (unsigned long)result;
58350   return jresult;
58351 }
58352
58353
58354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58355   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58356   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58357
58358   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58359   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58360   {
58361     try {
58362       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58363     } catch (std::out_of_range& e) {
58364       {
58365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58366       };
58367     } catch (std::exception& e) {
58368       {
58369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58370       };
58371     } catch (Dali::DaliException e) {
58372       {
58373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58374       };
58375     } catch (...) {
58376       {
58377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58378       };
58379     }
58380   }
58381
58382 }
58383
58384
58385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58386   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58387   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58388
58389   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58390   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58391   {
58392     try {
58393       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58394     } catch (std::out_of_range& e) {
58395       {
58396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58397       };
58398     } catch (std::exception& e) {
58399       {
58400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58401       };
58402     } catch (Dali::DaliException e) {
58403       {
58404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58405       };
58406     } catch (...) {
58407       {
58408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58409       };
58410     }
58411   }
58412
58413 }
58414
58415
58416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58417   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58418   Dali::Actor arg2 ;
58419   bool arg3 ;
58420   Dali::DevelActor::VisibilityChange::Type arg4 ;
58421   Dali::Actor *argp2 ;
58422
58423   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58424   argp2 = (Dali::Actor *)jarg2;
58425   if (!argp2) {
58426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58427     return ;
58428   }
58429   arg2 = *argp2;
58430   arg3 = jarg3 ? true : false;
58431   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58432   {
58433     try {
58434       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58435     } catch (std::out_of_range& e) {
58436       {
58437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58438       };
58439     } catch (std::exception& e) {
58440       {
58441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58442       };
58443     } catch (Dali::DaliException e) {
58444       {
58445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58446       };
58447     } catch (...) {
58448       {
58449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58450       };
58451     }
58452   }
58453
58454 }
58455
58456
58457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58458   void * jresult ;
58459   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58460
58461   {
58462     try {
58463       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58464     } catch (std::out_of_range& e) {
58465       {
58466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58467       };
58468     } catch (std::exception& e) {
58469       {
58470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58471       };
58472     } catch (Dali::DaliException e) {
58473       {
58474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58475       };
58476     } catch (...) {
58477       {
58478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58479       };
58480     }
58481   }
58482
58483   jresult = (void *)result;
58484   return jresult;
58485 }
58486
58487
58488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58489   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58490
58491   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58492   {
58493     try {
58494       delete arg1;
58495     } catch (std::out_of_range& e) {
58496       {
58497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58498       };
58499     } catch (std::exception& e) {
58500       {
58501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58502       };
58503     } catch (Dali::DaliException e) {
58504       {
58505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58506       };
58507     } catch (...) {
58508       {
58509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58510       };
58511     }
58512   }
58513
58514 }
58515
58516
58517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58518   void * jresult ;
58519   Dali::Timer *result = 0 ;
58520
58521   {
58522     try {
58523       result = (Dali::Timer *)new Dali::Timer();
58524     } catch (std::out_of_range& e) {
58525       {
58526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58527       };
58528     } catch (std::exception& e) {
58529       {
58530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58531       };
58532     } catch (Dali::DaliException e) {
58533       {
58534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58535       };
58536     } catch (...) {
58537       {
58538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58539       };
58540     }
58541   }
58542
58543   jresult = (void *)result;
58544   return jresult;
58545 }
58546
58547
58548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58549   void * jresult ;
58550   unsigned int arg1 ;
58551   Dali::Timer result;
58552
58553   arg1 = (unsigned int)jarg1;
58554   {
58555     try {
58556       result = Dali::Timer::New(arg1);
58557     } catch (std::out_of_range& e) {
58558       {
58559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58560       };
58561     } catch (std::exception& e) {
58562       {
58563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58564       };
58565     } catch (Dali::DaliException e) {
58566       {
58567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58568       };
58569     } catch (...) {
58570       {
58571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58572       };
58573     }
58574   }
58575
58576   jresult = new Dali::Timer((const Dali::Timer &)result);
58577   return jresult;
58578 }
58579
58580
58581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58582   void * jresult ;
58583   Dali::Timer *arg1 = 0 ;
58584   Dali::Timer *result = 0 ;
58585
58586   arg1 = (Dali::Timer *)jarg1;
58587   if (!arg1) {
58588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58589     return 0;
58590   }
58591   {
58592     try {
58593       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58594     } catch (std::out_of_range& e) {
58595       {
58596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58597       };
58598     } catch (std::exception& e) {
58599       {
58600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58601       };
58602     } catch (Dali::DaliException e) {
58603       {
58604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58605       };
58606     } catch (...) {
58607       {
58608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58609       };
58610     }
58611   }
58612
58613   jresult = (void *)result;
58614   return jresult;
58615 }
58616
58617
58618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58619   void * jresult ;
58620   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58621   Dali::Timer *arg2 = 0 ;
58622   Dali::Timer *result = 0 ;
58623
58624   arg1 = (Dali::Timer *)jarg1;
58625   arg2 = (Dali::Timer *)jarg2;
58626   if (!arg2) {
58627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58628     return 0;
58629   }
58630   {
58631     try {
58632       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58633     } catch (std::out_of_range& e) {
58634       {
58635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58636       };
58637     } catch (std::exception& e) {
58638       {
58639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58640       };
58641     } catch (Dali::DaliException e) {
58642       {
58643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58644       };
58645     } catch (...) {
58646       {
58647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58648       };
58649     }
58650   }
58651
58652   jresult = (void *)result;
58653   return jresult;
58654 }
58655
58656
58657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58658   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58659
58660   arg1 = (Dali::Timer *)jarg1;
58661   {
58662     try {
58663       delete arg1;
58664     } catch (std::out_of_range& e) {
58665       {
58666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58667       };
58668     } catch (std::exception& e) {
58669       {
58670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58671       };
58672     } catch (Dali::DaliException e) {
58673       {
58674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58675       };
58676     } catch (...) {
58677       {
58678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58679       };
58680     }
58681   }
58682
58683 }
58684
58685
58686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58687   void * jresult ;
58688   Dali::BaseHandle arg1 ;
58689   Dali::BaseHandle *argp1 ;
58690   Dali::Timer result;
58691
58692   argp1 = (Dali::BaseHandle *)jarg1;
58693   if (!argp1) {
58694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58695     return 0;
58696   }
58697   arg1 = *argp1;
58698   {
58699     try {
58700       result = Dali::Timer::DownCast(arg1);
58701     } catch (std::out_of_range& e) {
58702       {
58703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58704       };
58705     } catch (std::exception& e) {
58706       {
58707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58708       };
58709     } catch (Dali::DaliException e) {
58710       {
58711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58712       };
58713     } catch (...) {
58714       {
58715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58716       };
58717     }
58718   }
58719
58720   jresult = new Dali::Timer((const Dali::Timer &)result);
58721   return jresult;
58722 }
58723
58724
58725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58726   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58727
58728   arg1 = (Dali::Timer *)jarg1;
58729   {
58730     try {
58731       (arg1)->Start();
58732     } catch (std::out_of_range& e) {
58733       {
58734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58735       };
58736     } catch (std::exception& e) {
58737       {
58738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58739       };
58740     } catch (Dali::DaliException e) {
58741       {
58742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58743       };
58744     } catch (...) {
58745       {
58746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58747       };
58748     }
58749   }
58750
58751 }
58752
58753
58754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58755   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58756
58757   arg1 = (Dali::Timer *)jarg1;
58758   {
58759     try {
58760       (arg1)->Stop();
58761     } catch (std::out_of_range& e) {
58762       {
58763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58764       };
58765     } catch (std::exception& e) {
58766       {
58767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58768       };
58769     } catch (Dali::DaliException e) {
58770       {
58771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58772       };
58773     } catch (...) {
58774       {
58775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58776       };
58777     }
58778   }
58779
58780 }
58781
58782
58783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58784   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58785   unsigned int arg2 ;
58786
58787   arg1 = (Dali::Timer *)jarg1;
58788   arg2 = (unsigned int)jarg2;
58789   {
58790     try {
58791       (arg1)->SetInterval(arg2);
58792     } catch (std::out_of_range& e) {
58793       {
58794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58795       };
58796     } catch (std::exception& e) {
58797       {
58798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58799       };
58800     } catch (Dali::DaliException e) {
58801       {
58802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58803       };
58804     } catch (...) {
58805       {
58806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58807       };
58808     }
58809   }
58810
58811 }
58812
58813
58814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58815   unsigned int jresult ;
58816   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58817   unsigned int result;
58818
58819   arg1 = (Dali::Timer *)jarg1;
58820   {
58821     try {
58822       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58823     } catch (std::out_of_range& e) {
58824       {
58825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58826       };
58827     } catch (std::exception& e) {
58828       {
58829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58830       };
58831     } catch (Dali::DaliException e) {
58832       {
58833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58834       };
58835     } catch (...) {
58836       {
58837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58838       };
58839     }
58840   }
58841
58842   jresult = result;
58843   return jresult;
58844 }
58845
58846
58847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58848   unsigned int jresult ;
58849   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58850   bool result;
58851
58852   arg1 = (Dali::Timer *)jarg1;
58853   {
58854     try {
58855       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58856     } catch (std::out_of_range& e) {
58857       {
58858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58859       };
58860     } catch (std::exception& e) {
58861       {
58862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58863       };
58864     } catch (Dali::DaliException e) {
58865       {
58866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58867       };
58868     } catch (...) {
58869       {
58870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58871       };
58872     }
58873   }
58874
58875   jresult = result;
58876   return jresult;
58877 }
58878
58879
58880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58881   void * jresult ;
58882   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58883   Dali::Timer::TimerSignalType *result = 0 ;
58884
58885   arg1 = (Dali::Timer *)jarg1;
58886   {
58887     try {
58888       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58889     } catch (std::out_of_range& e) {
58890       {
58891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58892       };
58893     } catch (std::exception& e) {
58894       {
58895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58896       };
58897     } catch (Dali::DaliException e) {
58898       {
58899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58900       };
58901     } catch (...) {
58902       {
58903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58904       };
58905     }
58906   }
58907
58908   jresult = (void *)result;
58909   return jresult;
58910 }
58911
58912
58913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
58914   unsigned int jresult ;
58915   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58916   bool result;
58917
58918   arg1 = (Dali::Signal< bool () > *)jarg1;
58919   {
58920     try {
58921       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
58922     } catch (std::out_of_range& e) {
58923       {
58924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58925       };
58926     } catch (std::exception& e) {
58927       {
58928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58929       };
58930     } catch (Dali::DaliException e) {
58931       {
58932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58933       };
58934     } catch (...) {
58935       {
58936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58937       };
58938     }
58939   }
58940
58941   jresult = result;
58942   return jresult;
58943 }
58944
58945
58946 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
58947   unsigned long jresult ;
58948   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58949   std::size_t result;
58950
58951   arg1 = (Dali::Signal< bool () > *)jarg1;
58952   {
58953     try {
58954       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
58955     } catch (std::out_of_range& e) {
58956       {
58957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58958       };
58959     } catch (std::exception& e) {
58960       {
58961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58962       };
58963     } catch (Dali::DaliException e) {
58964       {
58965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58966       };
58967     } catch (...) {
58968       {
58969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58970       };
58971     }
58972   }
58973
58974   jresult = (unsigned long)result;
58975   return jresult;
58976 }
58977
58978
58979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
58980   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58981   bool (*arg2)() = (bool (*)()) 0 ;
58982
58983   arg1 = (Dali::Signal< bool () > *)jarg1;
58984   arg2 = (bool (*)())jarg2;
58985   {
58986     try {
58987       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
58988     } catch (std::out_of_range& e) {
58989       {
58990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58991       };
58992     } catch (std::exception& e) {
58993       {
58994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58995       };
58996     } catch (Dali::DaliException e) {
58997       {
58998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58999       };
59000     } catch (...) {
59001       {
59002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59003       };
59004     }
59005   }
59006
59007 }
59008
59009
59010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
59011   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59012   bool (*arg2)() = (bool (*)()) 0 ;
59013
59014   arg1 = (Dali::Signal< bool () > *)jarg1;
59015   arg2 = (bool (*)())jarg2;
59016   {
59017     try {
59018       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
59019     } catch (std::out_of_range& e) {
59020       {
59021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59022       };
59023     } catch (std::exception& e) {
59024       {
59025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59026       };
59027     } catch (Dali::DaliException e) {
59028       {
59029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59030       };
59031     } catch (...) {
59032       {
59033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59034       };
59035     }
59036   }
59037
59038 }
59039
59040
59041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
59042   unsigned int jresult ;
59043   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59044   bool result;
59045
59046   arg1 = (Dali::Signal< bool () > *)jarg1;
59047   {
59048     try {
59049       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
59050     } catch (std::out_of_range& e) {
59051       {
59052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59053       };
59054     } catch (std::exception& e) {
59055       {
59056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59057       };
59058     } catch (Dali::DaliException e) {
59059       {
59060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59061       };
59062     } catch (...) {
59063       {
59064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59065       };
59066     }
59067   }
59068
59069   jresult = result;
59070   return jresult;
59071 }
59072
59073
59074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
59075   void * jresult ;
59076   Dali::Signal< bool () > *result = 0 ;
59077
59078   {
59079     try {
59080       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59081     } catch (std::out_of_range& e) {
59082       {
59083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59084       };
59085     } catch (std::exception& e) {
59086       {
59087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59088       };
59089     } catch (Dali::DaliException e) {
59090       {
59091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59092       };
59093     } catch (...) {
59094       {
59095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59096       };
59097     }
59098   }
59099
59100   jresult = (void *)result;
59101   return jresult;
59102 }
59103
59104
59105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59106   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59107
59108   arg1 = (Dali::Signal< bool () > *)jarg1;
59109   {
59110     try {
59111       delete arg1;
59112     } catch (std::out_of_range& e) {
59113       {
59114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59115       };
59116     } catch (std::exception& e) {
59117       {
59118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59119       };
59120     } catch (Dali::DaliException e) {
59121       {
59122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59123       };
59124     } catch (...) {
59125       {
59126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59127       };
59128     }
59129   }
59130
59131 }
59132
59133
59134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59135   int jresult ;
59136   int result;
59137
59138   {
59139     try {
59140       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59141     } catch (std::out_of_range& e) {
59142       {
59143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59144       };
59145     } catch (std::exception& e) {
59146       {
59147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59148       };
59149     } catch (Dali::DaliException e) {
59150       {
59151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59152       };
59153     } catch (...) {
59154       {
59155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59156       };
59157     }
59158   }
59159
59160   jresult = (int)result;
59161   return jresult;
59162 }
59163
59164
59165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59166   int jresult ;
59167   int result;
59168
59169   {
59170     try {
59171       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59172     } catch (std::out_of_range& e) {
59173       {
59174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59175       };
59176     } catch (std::exception& e) {
59177       {
59178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59179       };
59180     } catch (Dali::DaliException e) {
59181       {
59182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59183       };
59184     } catch (...) {
59185       {
59186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59187       };
59188     }
59189   }
59190
59191   jresult = (int)result;
59192   return jresult;
59193 }
59194
59195
59196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59197   int jresult ;
59198   int result;
59199
59200   {
59201     try {
59202       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59203     } catch (std::out_of_range& e) {
59204       {
59205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59206       };
59207     } catch (std::exception& e) {
59208       {
59209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59210       };
59211     } catch (Dali::DaliException e) {
59212       {
59213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59214       };
59215     } catch (...) {
59216       {
59217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59218       };
59219     }
59220   }
59221
59222   jresult = (int)result;
59223   return jresult;
59224 }
59225
59226
59227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59228   int jresult ;
59229   int result;
59230
59231   {
59232     try {
59233       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59234     } catch (std::out_of_range& e) {
59235       {
59236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59237       };
59238     } catch (std::exception& e) {
59239       {
59240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59241       };
59242     } catch (Dali::DaliException e) {
59243       {
59244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59245       };
59246     } catch (...) {
59247       {
59248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59249       };
59250     }
59251   }
59252
59253   jresult = (int)result;
59254   return jresult;
59255 }
59256
59257
59258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59259   int jresult ;
59260   int result;
59261
59262   {
59263     try {
59264       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59265     } catch (std::out_of_range& e) {
59266       {
59267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59268       };
59269     } catch (std::exception& e) {
59270       {
59271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59272       };
59273     } catch (Dali::DaliException e) {
59274       {
59275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59276       };
59277     } catch (...) {
59278       {
59279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59280       };
59281     }
59282   }
59283
59284   jresult = (int)result;
59285   return jresult;
59286 }
59287
59288
59289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59290   int jresult ;
59291   int result;
59292
59293   {
59294     try {
59295       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59296     } catch (std::out_of_range& e) {
59297       {
59298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59299       };
59300     } catch (std::exception& e) {
59301       {
59302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59303       };
59304     } catch (Dali::DaliException e) {
59305       {
59306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59307       };
59308     } catch (...) {
59309       {
59310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59311       };
59312     }
59313   }
59314
59315   jresult = (int)result;
59316   return jresult;
59317 }
59318
59319
59320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59321   int jresult ;
59322   int result;
59323
59324   {
59325     try {
59326       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59327     } catch (std::out_of_range& e) {
59328       {
59329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59330       };
59331     } catch (std::exception& e) {
59332       {
59333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59334       };
59335     } catch (Dali::DaliException e) {
59336       {
59337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59338       };
59339     } catch (...) {
59340       {
59341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59342       };
59343     }
59344   }
59345
59346   jresult = (int)result;
59347   return jresult;
59348 }
59349
59350
59351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59352   int jresult ;
59353   int result;
59354
59355   {
59356     try {
59357       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59358     } catch (std::out_of_range& e) {
59359       {
59360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59361       };
59362     } catch (std::exception& e) {
59363       {
59364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59365       };
59366     } catch (Dali::DaliException e) {
59367       {
59368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59369       };
59370     } catch (...) {
59371       {
59372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59373       };
59374     }
59375   }
59376
59377   jresult = (int)result;
59378   return jresult;
59379 }
59380
59381
59382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59383   int jresult ;
59384   int result;
59385
59386   {
59387     try {
59388       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59389     } catch (std::out_of_range& e) {
59390       {
59391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59392       };
59393     } catch (std::exception& e) {
59394       {
59395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59396       };
59397     } catch (Dali::DaliException e) {
59398       {
59399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59400       };
59401     } catch (...) {
59402       {
59403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59404       };
59405     }
59406   }
59407
59408   jresult = (int)result;
59409   return jresult;
59410 }
59411
59412
59413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59414   int jresult ;
59415   int result;
59416
59417   {
59418     try {
59419       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59420     } catch (std::out_of_range& e) {
59421       {
59422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59423       };
59424     } catch (std::exception& e) {
59425       {
59426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59427       };
59428     } catch (Dali::DaliException e) {
59429       {
59430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59431       };
59432     } catch (...) {
59433       {
59434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59435       };
59436     }
59437   }
59438
59439   jresult = (int)result;
59440   return jresult;
59441 }
59442
59443
59444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59445   int jresult ;
59446   int result;
59447
59448   {
59449     try {
59450       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59451     } catch (std::out_of_range& e) {
59452       {
59453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59454       };
59455     } catch (std::exception& e) {
59456       {
59457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59458       };
59459     } catch (Dali::DaliException e) {
59460       {
59461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59462       };
59463     } catch (...) {
59464       {
59465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59466       };
59467     }
59468   }
59469
59470   jresult = (int)result;
59471   return jresult;
59472 }
59473
59474
59475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59476   int jresult ;
59477   int result;
59478
59479   {
59480     try {
59481       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59482     } catch (std::out_of_range& e) {
59483       {
59484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59485       };
59486     } catch (std::exception& e) {
59487       {
59488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59489       };
59490     } catch (Dali::DaliException e) {
59491       {
59492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59493       };
59494     } catch (...) {
59495       {
59496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59497       };
59498     }
59499   }
59500
59501   jresult = (int)result;
59502   return jresult;
59503 }
59504
59505
59506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59507   int jresult ;
59508   int result;
59509
59510   {
59511     try {
59512       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59513     } catch (std::out_of_range& e) {
59514       {
59515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59516       };
59517     } catch (std::exception& e) {
59518       {
59519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59520       };
59521     } catch (Dali::DaliException e) {
59522       {
59523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59524       };
59525     } catch (...) {
59526       {
59527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59528       };
59529     }
59530   }
59531
59532   jresult = (int)result;
59533   return jresult;
59534 }
59535
59536
59537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59538   int jresult ;
59539   int result;
59540
59541   {
59542     try {
59543       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59544     } catch (std::out_of_range& e) {
59545       {
59546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59547       };
59548     } catch (std::exception& e) {
59549       {
59550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59551       };
59552     } catch (Dali::DaliException e) {
59553       {
59554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59555       };
59556     } catch (...) {
59557       {
59558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59559       };
59560     }
59561   }
59562
59563   jresult = (int)result;
59564   return jresult;
59565 }
59566
59567
59568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59569   int jresult ;
59570   int result;
59571
59572   {
59573     try {
59574       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59575     } catch (std::out_of_range& e) {
59576       {
59577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59578       };
59579     } catch (std::exception& e) {
59580       {
59581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59582       };
59583     } catch (Dali::DaliException e) {
59584       {
59585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59586       };
59587     } catch (...) {
59588       {
59589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59590       };
59591     }
59592   }
59593
59594   jresult = (int)result;
59595   return jresult;
59596 }
59597
59598
59599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59600   int jresult ;
59601   int result;
59602
59603   {
59604     try {
59605       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59606     } catch (std::out_of_range& e) {
59607       {
59608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59609       };
59610     } catch (std::exception& e) {
59611       {
59612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59613       };
59614     } catch (Dali::DaliException e) {
59615       {
59616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59617       };
59618     } catch (...) {
59619       {
59620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59621       };
59622     }
59623   }
59624
59625   jresult = (int)result;
59626   return jresult;
59627 }
59628
59629
59630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59631   int jresult ;
59632   int result;
59633
59634   {
59635     try {
59636       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59637     } catch (std::out_of_range& e) {
59638       {
59639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59640       };
59641     } catch (std::exception& e) {
59642       {
59643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59644       };
59645     } catch (Dali::DaliException e) {
59646       {
59647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59648       };
59649     } catch (...) {
59650       {
59651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59652       };
59653     }
59654   }
59655
59656   jresult = (int)result;
59657   return jresult;
59658 }
59659
59660
59661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
59662   int jresult ;
59663   int result;
59664
59665   {
59666     try {
59667       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
59668     } catch (std::out_of_range& e) {
59669       {
59670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59671       };
59672     } catch (std::exception& e) {
59673       {
59674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59675       };
59676     } catch (Dali::DaliException e) {
59677       {
59678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59679       };
59680     } catch (...) {
59681       {
59682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59683       };
59684     }
59685   }
59686
59687   jresult = (int)result;
59688   return jresult;
59689 }
59690
59691
59692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
59693   int jresult ;
59694   int result;
59695
59696   {
59697     try {
59698       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
59699     } catch (std::out_of_range& e) {
59700       {
59701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59702       };
59703     } catch (std::exception& e) {
59704       {
59705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59706       };
59707     } catch (Dali::DaliException e) {
59708       {
59709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59710       };
59711     } catch (...) {
59712       {
59713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59714       };
59715     }
59716   }
59717
59718   jresult = (int)result;
59719   return jresult;
59720 }
59721
59722
59723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
59724   int jresult ;
59725   int result;
59726
59727   {
59728     try {
59729       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
59730     } catch (std::out_of_range& e) {
59731       {
59732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59733       };
59734     } catch (std::exception& e) {
59735       {
59736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59737       };
59738     } catch (Dali::DaliException e) {
59739       {
59740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59741       };
59742     } catch (...) {
59743       {
59744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59745       };
59746     }
59747   }
59748
59749   jresult = (int)result;
59750   return jresult;
59751 }
59752
59753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
59754   int jresult ;
59755   int result;
59756
59757   {
59758     try {
59759       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
59760     } catch (std::out_of_range& e) {
59761       {
59762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59763       };
59764     } catch (std::exception& e) {
59765       {
59766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59767       };
59768     } catch (Dali::DaliException e) {
59769       {
59770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59771       };
59772     } catch (...) {
59773       {
59774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59775       };
59776     }
59777   }
59778
59779   jresult = (int)result;
59780   return jresult;
59781 }
59782
59783
59784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
59785   int jresult ;
59786   int result;
59787   {
59788     try
59789     {
59790       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
59791     } catch (std::out_of_range& e) {
59792       {
59793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59794       };
59795     } catch (std::exception& e) {
59796       {
59797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59798       };
59799     } catch (Dali::DaliException e) {
59800       {
59801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59802       };
59803     } catch (...) {
59804       {
59805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59806       };
59807     }
59808   }
59809
59810   jresult = (int)result;
59811   return jresult;
59812 }
59813
59814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
59815   int jresult ;
59816   int result;
59817   {
59818     try
59819     {
59820       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
59821     } catch (std::out_of_range& e) {
59822       {
59823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59824       };
59825     } catch (std::exception& e) {
59826       {
59827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59828       };
59829     } catch (Dali::DaliException e) {
59830       {
59831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59832       };
59833     } catch (...) {
59834       {
59835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59836       };
59837     }
59838   }
59839
59840   jresult = (int)result;
59841   return jresult;
59842 }
59843
59844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
59845   int jresult ;
59846   int result;
59847   {
59848     try
59849     {
59850       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
59851     } catch (std::out_of_range& e) {
59852       {
59853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59854       };
59855     } catch (std::exception& e) {
59856       {
59857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59858       };
59859     } catch (Dali::DaliException e) {
59860       {
59861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59862       };
59863     } catch (...) {
59864       {
59865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59866       };
59867     }
59868   }
59869
59870   jresult = (int)result;
59871   return jresult;
59872 }
59873
59874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
59875   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
59876 }
59877
59878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
59879   int jresult ;
59880   int result;
59881   {
59882     try
59883     {
59884       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
59885     } catch (std::out_of_range& e) {
59886       {
59887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59888       };
59889     } catch (std::exception& e) {
59890       {
59891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59892       };
59893     } catch (Dali::DaliException e) {
59894       {
59895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59896       };
59897     } catch (...) {
59898       {
59899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59900       };
59901     }
59902   }
59903
59904   jresult = (int)result;
59905   return jresult;
59906 }
59907
59908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
59909   int jresult ;
59910   int result;
59911   {
59912     try
59913     {
59914       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
59915     } catch (std::out_of_range& e) {
59916       {
59917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59918       };
59919     } catch (std::exception& e) {
59920       {
59921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59922       };
59923     } catch (Dali::DaliException e) {
59924       {
59925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59926       };
59927     } catch (...) {
59928       {
59929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59930       };
59931     }
59932   }
59933
59934   jresult = (int)result;
59935   return jresult;
59936 }
59937
59938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
59939   int jresult ;
59940   int result;
59941
59942   {
59943     try {
59944       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
59945     } catch (std::out_of_range& e) {
59946       {
59947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59948       };
59949     } catch (std::exception& e) {
59950       {
59951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59952       };
59953     } catch (Dali::DaliException e) {
59954       {
59955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59956       };
59957     } catch (...) {
59958       {
59959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59960       };
59961     }
59962   }
59963
59964   jresult = (int)result;
59965   return jresult;
59966 }
59967
59968
59969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
59970   int jresult ;
59971   int result;
59972
59973   {
59974     try {
59975       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
59976     } catch (std::out_of_range& e) {
59977       {
59978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59979       };
59980     } catch (std::exception& e) {
59981       {
59982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59983       };
59984     } catch (Dali::DaliException e) {
59985       {
59986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59987       };
59988     } catch (...) {
59989       {
59990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59991       };
59992     }
59993   }
59994
59995   jresult = (int)result;
59996   return jresult;
59997 }
59998
59999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
60000   int jresult ;
60001   int result;
60002   {
60003     try
60004     {
60005       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
60006     } catch (std::out_of_range& e) {
60007       {
60008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60009       };
60010     } catch (std::exception& e) {
60011       {
60012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60013       };
60014     } catch (...) {
60015       {
60016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60017       };
60018     }
60019   }
60020   jresult = (int)result;
60021   return jresult;
60022 }
60023
60024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
60025   int jresult ;
60026   int result;
60027   {
60028     try
60029     {
60030       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
60031     } catch (std::out_of_range& e) {
60032       {
60033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60034       };
60035     } catch (std::exception& e) {
60036       {
60037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60038       };
60039     } catch (...) {
60040       {
60041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60042       };
60043     }
60044   }
60045   jresult = (int)result;
60046   return jresult;
60047 }
60048
60049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
60050   int jresult ;
60051   int result;
60052   {
60053     try
60054     {
60055       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
60056     } catch (std::out_of_range& e) {
60057       {
60058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60059       };
60060     } catch (std::exception& e) {
60061       {
60062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60063       };
60064     } catch (...) {
60065       {
60066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60067       };
60068     }
60069   }
60070   jresult = (int)result;
60071   return jresult;
60072 }
60073
60074
60075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
60076   int jresult ;
60077   int result;
60078   {
60079     try
60080     {
60081       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60082     } catch (std::out_of_range& e) {
60083       {
60084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60085       };
60086     } catch (std::exception& e) {
60087       {
60088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60089       };
60090     } catch (...) {
60091       {
60092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60093       };
60094     }
60095   }
60096   jresult = (int)result;
60097   return jresult;
60098 }
60099
60100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60101   int jresult ;
60102   int result;
60103   {
60104     try
60105     {
60106       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60107     } catch (std::out_of_range& e) {
60108       {
60109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60110       };
60111     } catch (std::exception& e) {
60112       {
60113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60114       };
60115     } catch (...) {
60116       {
60117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60118       };
60119     }
60120   }
60121   jresult = (int)result;
60122   return jresult;
60123 }
60124
60125
60126
60127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60128   int jresult ;
60129   int result;
60130
60131   {
60132     try {
60133       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60134     } catch (std::out_of_range& e) {
60135       {
60136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60137       };
60138     } catch (std::exception& e) {
60139       {
60140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60141       };
60142     } catch (Dali::DaliException e) {
60143       {
60144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60145       };
60146     } catch (...) {
60147       {
60148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60149       };
60150     }
60151   }
60152
60153   jresult = (int)result;
60154   return jresult;
60155 }
60156
60157
60158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60159   int jresult ;
60160   int result;
60161
60162   {
60163     try {
60164       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60165     } catch (std::out_of_range& e) {
60166       {
60167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60168       };
60169     } catch (std::exception& e) {
60170       {
60171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60172       };
60173     } catch (Dali::DaliException e) {
60174       {
60175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60176       };
60177     } catch (...) {
60178       {
60179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60180       };
60181     }
60182   }
60183
60184   jresult = (int)result;
60185   return jresult;
60186 }
60187
60188
60189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60190   int jresult ;
60191   int result;
60192
60193   {
60194     try {
60195       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60196     } catch (std::out_of_range& e) {
60197       {
60198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60199       };
60200     } catch (std::exception& e) {
60201       {
60202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60203       };
60204     } catch (Dali::DaliException e) {
60205       {
60206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60207       };
60208     } catch (...) {
60209       {
60210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60211       };
60212     }
60213   }
60214
60215   jresult = (int)result;
60216   return jresult;
60217 }
60218
60219
60220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60221   int jresult ;
60222   int result;
60223
60224   {
60225     try {
60226       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60227     } catch (std::out_of_range& e) {
60228       {
60229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60230       };
60231     } catch (std::exception& e) {
60232       {
60233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60234       };
60235     } catch (Dali::DaliException e) {
60236       {
60237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60238       };
60239     } catch (...) {
60240       {
60241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60242       };
60243     }
60244   }
60245
60246   jresult = (int)result;
60247   return jresult;
60248 }
60249
60250
60251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60252   int jresult ;
60253   int result;
60254
60255   {
60256     try {
60257       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60258     } catch (std::out_of_range& e) {
60259       {
60260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60261       };
60262     } catch (std::exception& e) {
60263       {
60264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60265       };
60266     } catch (Dali::DaliException e) {
60267       {
60268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60269       };
60270     } catch (...) {
60271       {
60272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60273       };
60274     }
60275   }
60276
60277   jresult = (int)result;
60278   return jresult;
60279 }
60280
60281
60282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60283   int jresult ;
60284   int result;
60285
60286   {
60287     try {
60288       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60289     } catch (std::out_of_range& e) {
60290       {
60291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60292       };
60293     } catch (std::exception& e) {
60294       {
60295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60296       };
60297     } catch (Dali::DaliException e) {
60298       {
60299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60300       };
60301     } catch (...) {
60302       {
60303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60304       };
60305     }
60306   }
60307
60308   jresult = (int)result;
60309   return jresult;
60310 }
60311
60312
60313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60314   int jresult ;
60315   int result;
60316
60317   {
60318     try {
60319       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60320     } catch (std::out_of_range& e) {
60321       {
60322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60323       };
60324     } catch (std::exception& e) {
60325       {
60326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60327       };
60328     } catch (Dali::DaliException e) {
60329       {
60330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60331       };
60332     } catch (...) {
60333       {
60334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60335       };
60336     }
60337   }
60338
60339   jresult = (int)result;
60340   return jresult;
60341 }
60342
60343 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60344   int jresult ;
60345   int result;
60346
60347   {
60348     try {
60349       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60350     } catch (std::out_of_range& e) {
60351       {
60352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60353       };
60354     } catch (std::exception& e) {
60355       {
60356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60357       };
60358     } catch (...) {
60359       {
60360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60361       };
60362     }
60363   }
60364   jresult = (int)result;
60365   return jresult;
60366 }
60367
60368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60369   int jresult ;
60370   int result;
60371
60372   {
60373     try {
60374       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60375     } catch (std::out_of_range& e) {
60376       {
60377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60378       };
60379     } catch (std::exception& e) {
60380       {
60381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60382       };
60383     } catch (Dali::DaliException e) {
60384       {
60385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60386       };
60387     } catch (...) {
60388       {
60389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60390       };
60391     }
60392   }
60393
60394   jresult = (int)result;
60395   return jresult;
60396 }
60397
60398
60399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60400   int jresult ;
60401   int result;
60402
60403   {
60404     try {
60405       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60406     } catch (std::out_of_range& e) {
60407       {
60408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60409       };
60410     } catch (std::exception& e) {
60411       {
60412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60413       };
60414     } catch (Dali::DaliException e) {
60415       {
60416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60417       };
60418     } catch (...) {
60419       {
60420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60421       };
60422     }
60423   }
60424
60425   jresult = (int)result;
60426   return jresult;
60427 }
60428
60429
60430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60431   int jresult ;
60432   int result;
60433
60434   {
60435     try {
60436       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60437     } catch (std::out_of_range& e) {
60438       {
60439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60440       };
60441     } catch (std::exception& e) {
60442       {
60443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60444       };
60445     } catch (Dali::DaliException e) {
60446       {
60447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60448       };
60449     } catch (...) {
60450       {
60451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60452       };
60453     }
60454   }
60455
60456   jresult = (int)result;
60457   return jresult;
60458 }
60459
60460
60461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60462   int jresult ;
60463   int result;
60464
60465   {
60466     try {
60467       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60468     } catch (std::out_of_range& e) {
60469       {
60470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60471       };
60472     } catch (std::exception& e) {
60473       {
60474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60475       };
60476     } catch (Dali::DaliException e) {
60477       {
60478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60479       };
60480     } catch (...) {
60481       {
60482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60483       };
60484     }
60485   }
60486
60487   jresult = (int)result;
60488   return jresult;
60489 }
60490
60491
60492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60493   int jresult ;
60494   int result;
60495
60496   {
60497     try {
60498       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60499     } catch (std::out_of_range& e) {
60500       {
60501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60502       };
60503     } catch (std::exception& e) {
60504       {
60505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60506       };
60507     } catch (Dali::DaliException e) {
60508       {
60509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60510       };
60511     } catch (...) {
60512       {
60513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60514       };
60515     }
60516   }
60517
60518   jresult = (int)result;
60519   return jresult;
60520 }
60521
60522
60523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60524   int jresult ;
60525   int result;
60526
60527   {
60528     try {
60529       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60530     } catch (std::out_of_range& e) {
60531       {
60532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60533       };
60534     } catch (std::exception& e) {
60535       {
60536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60537       };
60538     } catch (Dali::DaliException e) {
60539       {
60540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60541       };
60542     } catch (...) {
60543       {
60544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60545       };
60546     }
60547   }
60548
60549   jresult = (int)result;
60550   return jresult;
60551 }
60552
60553
60554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60555   int jresult ;
60556   int result;
60557
60558   {
60559     try {
60560       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60561     } catch (std::out_of_range& e) {
60562       {
60563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60564       };
60565     } catch (std::exception& e) {
60566       {
60567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60568       };
60569     } catch (Dali::DaliException e) {
60570       {
60571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60572       };
60573     } catch (...) {
60574       {
60575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60576       };
60577     }
60578   }
60579
60580   jresult = (int)result;
60581   return jresult;
60582 }
60583
60584
60585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60586   int jresult ;
60587   int result;
60588
60589   {
60590     try {
60591       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60592     } catch (std::out_of_range& e) {
60593       {
60594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60595       };
60596     } catch (std::exception& e) {
60597       {
60598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60599       };
60600     } catch (Dali::DaliException e) {
60601       {
60602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60603       };
60604     } catch (...) {
60605       {
60606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60607       };
60608     }
60609   }
60610
60611   jresult = (int)result;
60612   return jresult;
60613 }
60614
60615
60616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60617   int jresult ;
60618   int result;
60619
60620   {
60621     try {
60622       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60623     } catch (std::out_of_range& e) {
60624       {
60625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60626       };
60627     } catch (std::exception& e) {
60628       {
60629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60630       };
60631     } catch (Dali::DaliException e) {
60632       {
60633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60634       };
60635     } catch (...) {
60636       {
60637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60638       };
60639     }
60640   }
60641
60642   jresult = (int)result;
60643   return jresult;
60644 }
60645
60646
60647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60648   int jresult ;
60649   int result;
60650
60651   {
60652     try {
60653       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
60654     } catch (std::out_of_range& e) {
60655       {
60656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60657       };
60658     } catch (std::exception& e) {
60659       {
60660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60661       };
60662     } catch (Dali::DaliException e) {
60663       {
60664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60665       };
60666     } catch (...) {
60667       {
60668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60669       };
60670     }
60671   }
60672
60673   jresult = (int)result;
60674   return jresult;
60675 }
60676
60677
60678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
60679   int jresult ;
60680   int result;
60681
60682   {
60683     try {
60684       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
60685     } catch (std::out_of_range& e) {
60686       {
60687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60688       };
60689     } catch (std::exception& e) {
60690       {
60691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60692       };
60693     } catch (Dali::DaliException e) {
60694       {
60695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60696       };
60697     } catch (...) {
60698       {
60699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60700       };
60701     }
60702   }
60703
60704   jresult = (int)result;
60705   return jresult;
60706 }
60707
60708
60709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
60710   int jresult ;
60711   int result;
60712
60713   {
60714     try {
60715       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
60716     } catch (std::out_of_range& e) {
60717       {
60718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60719       };
60720     } catch (std::exception& e) {
60721       {
60722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60723       };
60724     } catch (Dali::DaliException e) {
60725       {
60726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60727       };
60728     } catch (...) {
60729       {
60730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60731       };
60732     }
60733   }
60734
60735   jresult = (int)result;
60736   return jresult;
60737 }
60738
60739
60740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
60741   int jresult ;
60742   int result;
60743
60744   {
60745     try {
60746       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
60747     } catch (std::out_of_range& e) {
60748       {
60749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60750       };
60751     } catch (std::exception& e) {
60752       {
60753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60754       };
60755     } catch (Dali::DaliException e) {
60756       {
60757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60758       };
60759     } catch (...) {
60760       {
60761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60762       };
60763     }
60764   }
60765
60766   jresult = (int)result;
60767   return jresult;
60768 }
60769
60770
60771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
60772   int jresult ;
60773   int result;
60774
60775   {
60776     try {
60777       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
60778     } catch (std::out_of_range& e) {
60779       {
60780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60781       };
60782     } catch (std::exception& e) {
60783       {
60784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60785       };
60786     } catch (Dali::DaliException e) {
60787       {
60788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60789       };
60790     } catch (...) {
60791       {
60792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60793       };
60794     }
60795   }
60796
60797   jresult = (int)result;
60798   return jresult;
60799 }
60800
60801
60802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
60803   int jresult ;
60804   int result;
60805
60806   {
60807     try {
60808       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
60809     } catch (std::out_of_range& e) {
60810       {
60811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60812       };
60813     } catch (std::exception& e) {
60814       {
60815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60816       };
60817     } catch (Dali::DaliException e) {
60818       {
60819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60820       };
60821     } catch (...) {
60822       {
60823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60824       };
60825     }
60826   }
60827
60828   jresult = (int)result;
60829   return jresult;
60830 }
60831
60832
60833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
60834   int jresult ;
60835   int result;
60836
60837   {
60838     try {
60839       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
60840     } catch (std::out_of_range& e) {
60841       {
60842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60843       };
60844     } catch (std::exception& e) {
60845       {
60846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60847       };
60848     } catch (Dali::DaliException e) {
60849       {
60850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60851       };
60852     } catch (...) {
60853       {
60854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60855       };
60856     }
60857   }
60858
60859   jresult = (int)result;
60860   return jresult;
60861 }
60862
60863
60864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
60865   int jresult ;
60866   int result;
60867
60868   {
60869     try {
60870       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
60871     } catch (std::out_of_range& e) {
60872       {
60873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60874       };
60875     } catch (std::exception& e) {
60876       {
60877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60878       };
60879     } catch (Dali::DaliException e) {
60880       {
60881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60882       };
60883     } catch (...) {
60884       {
60885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60886       };
60887     }
60888   }
60889
60890   jresult = (int)result;
60891   return jresult;
60892 }
60893
60894
60895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
60896   int jresult ;
60897   int result;
60898
60899   {
60900     try {
60901       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
60902     } catch (std::out_of_range& e) {
60903       {
60904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60905       };
60906     } catch (std::exception& e) {
60907       {
60908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60909       };
60910     } catch (Dali::DaliException e) {
60911       {
60912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60913       };
60914     } catch (...) {
60915       {
60916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60917       };
60918     }
60919   }
60920
60921   jresult = (int)result;
60922   return jresult;
60923 }
60924
60925
60926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
60927   int jresult ;
60928   int result;
60929
60930   {
60931     try {
60932       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
60933     } catch (std::out_of_range& e) {
60934       {
60935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60936       };
60937     } catch (std::exception& e) {
60938       {
60939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60940       };
60941     } catch (Dali::DaliException e) {
60942       {
60943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60944       };
60945     } catch (...) {
60946       {
60947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60948       };
60949     }
60950   }
60951
60952   jresult = (int)result;
60953   return jresult;
60954 }
60955
60956
60957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
60958   int jresult ;
60959   int result;
60960
60961   {
60962     try {
60963       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
60964     } catch (std::out_of_range& e) {
60965       {
60966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60967       };
60968     } catch (std::exception& e) {
60969       {
60970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60971       };
60972     } catch (Dali::DaliException e) {
60973       {
60974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60975       };
60976     } catch (...) {
60977       {
60978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60979       };
60980     }
60981   }
60982
60983   jresult = (int)result;
60984   return jresult;
60985 }
60986
60987
60988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
60989   int jresult ;
60990   int result;
60991
60992   {
60993     try {
60994       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
60995     } catch (std::out_of_range& e) {
60996       {
60997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60998       };
60999     } catch (std::exception& e) {
61000       {
61001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61002       };
61003     } catch (Dali::DaliException e) {
61004       {
61005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61006       };
61007     } catch (...) {
61008       {
61009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61010       };
61011     }
61012   }
61013
61014   jresult = (int)result;
61015   return jresult;
61016 }
61017
61018
61019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
61020   int jresult ;
61021   int result;
61022
61023   {
61024     try {
61025       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
61026     } catch (std::out_of_range& e) {
61027       {
61028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61029       };
61030     } catch (std::exception& e) {
61031       {
61032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61033       };
61034     } catch (Dali::DaliException e) {
61035       {
61036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61037       };
61038     } catch (...) {
61039       {
61040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61041       };
61042     }
61043   }
61044
61045   jresult = (int)result;
61046   return jresult;
61047 }
61048
61049
61050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
61051   int jresult ;
61052   int result;
61053
61054   {
61055     try {
61056       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
61057     } catch (std::out_of_range& e) {
61058       {
61059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61060       };
61061     } catch (std::exception& e) {
61062       {
61063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61064       };
61065     } catch (Dali::DaliException e) {
61066       {
61067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61068       };
61069     } catch (...) {
61070       {
61071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61072       };
61073     }
61074   }
61075
61076   jresult = (int)result;
61077   return jresult;
61078 }
61079
61080
61081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61082   int jresult ;
61083   int result;
61084
61085   {
61086     try {
61087       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61088     } catch (std::out_of_range& e) {
61089       {
61090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61091       };
61092     } catch (std::exception& e) {
61093       {
61094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61095       };
61096     } catch (Dali::DaliException e) {
61097       {
61098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61099       };
61100     } catch (...) {
61101       {
61102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61103       };
61104     }
61105   }
61106
61107   jresult = (int)result;
61108   return jresult;
61109 }
61110
61111
61112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61113   int jresult ;
61114   int result;
61115
61116   {
61117     try {
61118       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61119     } catch (std::out_of_range& e) {
61120       {
61121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61122       };
61123     } catch (std::exception& e) {
61124       {
61125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61126       };
61127     } catch (Dali::DaliException e) {
61128       {
61129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61130       };
61131     } catch (...) {
61132       {
61133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61134       };
61135     }
61136   }
61137
61138   jresult = (int)result;
61139   return jresult;
61140 }
61141
61142
61143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61144   int jresult ;
61145   int result;
61146
61147   {
61148     try {
61149       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61150     } catch (std::out_of_range& e) {
61151       {
61152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61153       };
61154     } catch (std::exception& e) {
61155       {
61156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61157       };
61158     } catch (Dali::DaliException e) {
61159       {
61160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61161       };
61162     } catch (...) {
61163       {
61164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61165       };
61166     }
61167   }
61168
61169   jresult = (int)result;
61170   return jresult;
61171 }
61172
61173
61174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61175   int jresult ;
61176   int result;
61177
61178   {
61179     try {
61180       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61181     } catch (std::out_of_range& e) {
61182       {
61183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61184       };
61185     } catch (std::exception& e) {
61186       {
61187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61188       };
61189     } catch (Dali::DaliException e) {
61190       {
61191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61192       };
61193     } catch (...) {
61194       {
61195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61196       };
61197     }
61198   }
61199
61200   jresult = (int)result;
61201   return jresult;
61202 }
61203
61204
61205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61206   int jresult ;
61207   int result;
61208
61209   {
61210     try {
61211       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61212     } catch (std::out_of_range& e) {
61213       {
61214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61215       };
61216     } catch (std::exception& e) {
61217       {
61218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61219       };
61220     } catch (Dali::DaliException e) {
61221       {
61222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61223       };
61224     } catch (...) {
61225       {
61226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61227       };
61228     }
61229   }
61230
61231   jresult = (int)result;
61232   return jresult;
61233 }
61234
61235
61236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61237   void * jresult ;
61238   Dali::Toolkit::Builder *result = 0 ;
61239
61240   {
61241     try {
61242       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61243     } catch (std::out_of_range& e) {
61244       {
61245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61246       };
61247     } catch (std::exception& e) {
61248       {
61249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61250       };
61251     } catch (Dali::DaliException e) {
61252       {
61253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61254       };
61255     } catch (...) {
61256       {
61257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61258       };
61259     }
61260   }
61261
61262   jresult = (void *)result;
61263   return jresult;
61264 }
61265
61266
61267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61268   void * jresult ;
61269   Dali::Toolkit::Builder result;
61270
61271   {
61272     try {
61273       result = Dali::Toolkit::Builder::New();
61274     } catch (std::out_of_range& e) {
61275       {
61276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61277       };
61278     } catch (std::exception& e) {
61279       {
61280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61281       };
61282     } catch (Dali::DaliException e) {
61283       {
61284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61285       };
61286     } catch (...) {
61287       {
61288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61289       };
61290     }
61291   }
61292
61293   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61294   return jresult;
61295 }
61296
61297
61298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61299   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61300
61301   arg1 = (Dali::Toolkit::Builder *)jarg1;
61302   {
61303     try {
61304       delete arg1;
61305     } catch (std::out_of_range& e) {
61306       {
61307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61308       };
61309     } catch (std::exception& e) {
61310       {
61311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61312       };
61313     } catch (Dali::DaliException e) {
61314       {
61315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61316       };
61317     } catch (...) {
61318       {
61319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61320       };
61321     }
61322   }
61323
61324 }
61325
61326
61327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61328   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61329   std::string *arg2 = 0 ;
61330   Dali::Toolkit::Builder::UIFormat arg3 ;
61331
61332   arg1 = (Dali::Toolkit::Builder *)jarg1;
61333   if (!jarg2) {
61334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61335     return ;
61336   }
61337   std::string arg2_str(jarg2);
61338   arg2 = &arg2_str;
61339   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61340   {
61341     try {
61342       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61343     } catch (std::out_of_range& e) {
61344       {
61345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61346       };
61347     } catch (std::exception& e) {
61348       {
61349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61350       };
61351     } catch (Dali::DaliException e) {
61352       {
61353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61354       };
61355     } catch (...) {
61356       {
61357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61358       };
61359     }
61360   }
61361
61362
61363   //argout typemap for const std::string&
61364
61365 }
61366
61367
61368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61369   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61370   std::string *arg2 = 0 ;
61371
61372   arg1 = (Dali::Toolkit::Builder *)jarg1;
61373   if (!jarg2) {
61374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61375     return ;
61376   }
61377   std::string arg2_str(jarg2);
61378   arg2 = &arg2_str;
61379   {
61380     try {
61381       (arg1)->LoadFromString((std::string const &)*arg2);
61382     } catch (std::out_of_range& e) {
61383       {
61384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61385       };
61386     } catch (std::exception& e) {
61387       {
61388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61389       };
61390     } catch (Dali::DaliException e) {
61391       {
61392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61393       };
61394     } catch (...) {
61395       {
61396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61397       };
61398     }
61399   }
61400
61401
61402   //argout typemap for const std::string&
61403
61404 }
61405
61406
61407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61408   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61409   Dali::Property::Map *arg2 = 0 ;
61410
61411   arg1 = (Dali::Toolkit::Builder *)jarg1;
61412   arg2 = (Dali::Property::Map *)jarg2;
61413   if (!arg2) {
61414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61415     return ;
61416   }
61417   {
61418     try {
61419       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61420     } catch (std::out_of_range& e) {
61421       {
61422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61423       };
61424     } catch (std::exception& e) {
61425       {
61426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61427       };
61428     } catch (Dali::DaliException e) {
61429       {
61430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61431       };
61432     } catch (...) {
61433       {
61434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61435       };
61436     }
61437   }
61438
61439 }
61440
61441
61442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61443   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61444   std::string *arg2 = 0 ;
61445   Dali::Property::Value *arg3 = 0 ;
61446
61447   arg1 = (Dali::Toolkit::Builder *)jarg1;
61448   if (!jarg2) {
61449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61450     return ;
61451   }
61452   std::string arg2_str(jarg2);
61453   arg2 = &arg2_str;
61454   arg3 = (Dali::Property::Value *)jarg3;
61455   if (!arg3) {
61456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61457     return ;
61458   }
61459   {
61460     try {
61461       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61462     } catch (std::out_of_range& e) {
61463       {
61464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61465       };
61466     } catch (std::exception& e) {
61467       {
61468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61469       };
61470     } catch (Dali::DaliException e) {
61471       {
61472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61473       };
61474     } catch (...) {
61475       {
61476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61477       };
61478     }
61479   }
61480
61481
61482   //argout typemap for const std::string&
61483
61484 }
61485
61486
61487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61488   void * jresult ;
61489   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61490   Dali::Property::Map *result = 0 ;
61491
61492   arg1 = (Dali::Toolkit::Builder *)jarg1;
61493   {
61494     try {
61495       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61496     } catch (std::out_of_range& e) {
61497       {
61498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61499       };
61500     } catch (std::exception& e) {
61501       {
61502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61503       };
61504     } catch (Dali::DaliException e) {
61505       {
61506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61507       };
61508     } catch (...) {
61509       {
61510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61511       };
61512     }
61513   }
61514
61515   jresult = (void *)result;
61516   return jresult;
61517 }
61518
61519
61520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61521   void * jresult ;
61522   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61523   std::string *arg2 = 0 ;
61524   Dali::Property::Value *result = 0 ;
61525
61526   arg1 = (Dali::Toolkit::Builder *)jarg1;
61527   if (!jarg2) {
61528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61529     return 0;
61530   }
61531   std::string arg2_str(jarg2);
61532   arg2 = &arg2_str;
61533   {
61534     try {
61535       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61536     } catch (std::out_of_range& e) {
61537       {
61538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61539       };
61540     } catch (std::exception& e) {
61541       {
61542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61543       };
61544     } catch (Dali::DaliException e) {
61545       {
61546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61547       };
61548     } catch (...) {
61549       {
61550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61551       };
61552     }
61553   }
61554
61555   jresult = (void *)result;
61556
61557   //argout typemap for const std::string&
61558
61559   return jresult;
61560 }
61561
61562
61563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61564   void * jresult ;
61565   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61566   std::string *arg2 = 0 ;
61567   Dali::Animation result;
61568
61569   arg1 = (Dali::Toolkit::Builder *)jarg1;
61570   if (!jarg2) {
61571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61572     return 0;
61573   }
61574   std::string arg2_str(jarg2);
61575   arg2 = &arg2_str;
61576   {
61577     try {
61578       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61579     } catch (std::out_of_range& e) {
61580       {
61581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61582       };
61583     } catch (std::exception& e) {
61584       {
61585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61586       };
61587     } catch (Dali::DaliException e) {
61588       {
61589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61590       };
61591     } catch (...) {
61592       {
61593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61594       };
61595     }
61596   }
61597
61598   jresult = new Dali::Animation((const Dali::Animation &)result);
61599
61600   //argout typemap for const std::string&
61601
61602   return jresult;
61603 }
61604
61605
61606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61607   void * jresult ;
61608   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61609   std::string *arg2 = 0 ;
61610   Dali::Property::Map *arg3 = 0 ;
61611   Dali::Animation result;
61612
61613   arg1 = (Dali::Toolkit::Builder *)jarg1;
61614   if (!jarg2) {
61615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61616     return 0;
61617   }
61618   std::string arg2_str(jarg2);
61619   arg2 = &arg2_str;
61620   arg3 = (Dali::Property::Map *)jarg3;
61621   if (!arg3) {
61622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61623     return 0;
61624   }
61625   {
61626     try {
61627       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61628     } catch (std::out_of_range& e) {
61629       {
61630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61631       };
61632     } catch (std::exception& e) {
61633       {
61634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61635       };
61636     } catch (Dali::DaliException e) {
61637       {
61638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61639       };
61640     } catch (...) {
61641       {
61642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61643       };
61644     }
61645   }
61646
61647   jresult = new Dali::Animation((const Dali::Animation &)result);
61648
61649   //argout typemap for const std::string&
61650
61651   return jresult;
61652 }
61653
61654
61655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
61656   void * jresult ;
61657   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61658   std::string *arg2 = 0 ;
61659   Dali::Actor arg3 ;
61660   Dali::Actor *argp3 ;
61661   Dali::Animation result;
61662
61663   arg1 = (Dali::Toolkit::Builder *)jarg1;
61664   if (!jarg2) {
61665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61666     return 0;
61667   }
61668   std::string arg2_str(jarg2);
61669   arg2 = &arg2_str;
61670   argp3 = (Dali::Actor *)jarg3;
61671   if (!argp3) {
61672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61673     return 0;
61674   }
61675   arg3 = *argp3;
61676   {
61677     try {
61678       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
61679     } catch (std::out_of_range& e) {
61680       {
61681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61682       };
61683     } catch (std::exception& e) {
61684       {
61685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61686       };
61687     } catch (Dali::DaliException e) {
61688       {
61689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61690       };
61691     } catch (...) {
61692       {
61693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61694       };
61695     }
61696   }
61697
61698   jresult = new Dali::Animation((const Dali::Animation &)result);
61699
61700   //argout typemap for const std::string&
61701
61702   return jresult;
61703 }
61704
61705
61706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
61707   void * jresult ;
61708   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61709   std::string *arg2 = 0 ;
61710   Dali::Property::Map *arg3 = 0 ;
61711   Dali::Actor arg4 ;
61712   Dali::Actor *argp4 ;
61713   Dali::Animation result;
61714
61715   arg1 = (Dali::Toolkit::Builder *)jarg1;
61716   if (!jarg2) {
61717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61718     return 0;
61719   }
61720   std::string arg2_str(jarg2);
61721   arg2 = &arg2_str;
61722   arg3 = (Dali::Property::Map *)jarg3;
61723   if (!arg3) {
61724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61725     return 0;
61726   }
61727   argp4 = (Dali::Actor *)jarg4;
61728   if (!argp4) {
61729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61730     return 0;
61731   }
61732   arg4 = *argp4;
61733   {
61734     try {
61735       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
61736     } catch (std::out_of_range& e) {
61737       {
61738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61739       };
61740     } catch (std::exception& e) {
61741       {
61742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61743       };
61744     } catch (Dali::DaliException e) {
61745       {
61746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61747       };
61748     } catch (...) {
61749       {
61750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61751       };
61752     }
61753   }
61754
61755   jresult = new Dali::Animation((const Dali::Animation &)result);
61756
61757   //argout typemap for const std::string&
61758
61759   return jresult;
61760 }
61761
61762
61763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
61764   void * jresult ;
61765   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61766   std::string *arg2 = 0 ;
61767   Dali::BaseHandle result;
61768
61769   arg1 = (Dali::Toolkit::Builder *)jarg1;
61770   if (!jarg2) {
61771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61772     return 0;
61773   }
61774   std::string arg2_str(jarg2);
61775   arg2 = &arg2_str;
61776   {
61777     try {
61778       result = (arg1)->Create((std::string const &)*arg2);
61779     } catch (std::out_of_range& e) {
61780       {
61781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61782       };
61783     } catch (std::exception& e) {
61784       {
61785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61786       };
61787     } catch (Dali::DaliException e) {
61788       {
61789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61790       };
61791     } catch (...) {
61792       {
61793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61794       };
61795     }
61796   }
61797
61798   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61799
61800   //argout typemap for const std::string&
61801
61802   return jresult;
61803 }
61804
61805
61806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61807   void * jresult ;
61808   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61809   std::string *arg2 = 0 ;
61810   Dali::Property::Map *arg3 = 0 ;
61811   Dali::BaseHandle result;
61812
61813   arg1 = (Dali::Toolkit::Builder *)jarg1;
61814   if (!jarg2) {
61815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61816     return 0;
61817   }
61818   std::string arg2_str(jarg2);
61819   arg2 = &arg2_str;
61820   arg3 = (Dali::Property::Map *)jarg3;
61821   if (!arg3) {
61822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61823     return 0;
61824   }
61825   {
61826     try {
61827       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61828     } catch (std::out_of_range& e) {
61829       {
61830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61831       };
61832     } catch (std::exception& e) {
61833       {
61834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61835       };
61836     } catch (Dali::DaliException e) {
61837       {
61838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61839       };
61840     } catch (...) {
61841       {
61842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61843       };
61844     }
61845   }
61846
61847   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61848
61849   //argout typemap for const std::string&
61850
61851   return jresult;
61852 }
61853
61854
61855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
61856   void * jresult ;
61857   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61858   std::string *arg2 = 0 ;
61859   Dali::BaseHandle result;
61860
61861   arg1 = (Dali::Toolkit::Builder *)jarg1;
61862   if (!jarg2) {
61863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61864     return 0;
61865   }
61866   std::string arg2_str(jarg2);
61867   arg2 = &arg2_str;
61868   {
61869     try {
61870       result = (arg1)->CreateFromJson((std::string const &)*arg2);
61871     } catch (std::out_of_range& e) {
61872       {
61873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61874       };
61875     } catch (std::exception& e) {
61876       {
61877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61878       };
61879     } catch (Dali::DaliException e) {
61880       {
61881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61882       };
61883     } catch (...) {
61884       {
61885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61886       };
61887     }
61888   }
61889
61890   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61891
61892   //argout typemap for const std::string&
61893
61894   return jresult;
61895 }
61896
61897
61898 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
61899   unsigned int jresult ;
61900   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61901   std::string *arg2 = 0 ;
61902   Dali::Handle *arg3 = 0 ;
61903   bool result;
61904
61905   arg1 = (Dali::Toolkit::Builder *)jarg1;
61906   if (!jarg2) {
61907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61908     return 0;
61909   }
61910   std::string arg2_str(jarg2);
61911   arg2 = &arg2_str;
61912   arg3 = (Dali::Handle *)jarg3;
61913   if (!arg3) {
61914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61915     return 0;
61916   }
61917   {
61918     try {
61919       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
61920     } catch (std::out_of_range& e) {
61921       {
61922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61923       };
61924     } catch (std::exception& e) {
61925       {
61926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61927       };
61928     } catch (Dali::DaliException e) {
61929       {
61930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61931       };
61932     } catch (...) {
61933       {
61934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61935       };
61936     }
61937   }
61938
61939   jresult = result;
61940
61941   //argout typemap for const std::string&
61942
61943   return jresult;
61944 }
61945
61946
61947 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
61948   unsigned int jresult ;
61949   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61950   Dali::Handle *arg2 = 0 ;
61951   std::string *arg3 = 0 ;
61952   bool result;
61953
61954   arg1 = (Dali::Toolkit::Builder *)jarg1;
61955   arg2 = (Dali::Handle *)jarg2;
61956   if (!arg2) {
61957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61958     return 0;
61959   }
61960   if (!jarg3) {
61961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61962     return 0;
61963   }
61964   std::string arg3_str(jarg3);
61965   arg3 = &arg3_str;
61966   {
61967     try {
61968       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
61969     } catch (std::out_of_range& e) {
61970       {
61971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61972       };
61973     } catch (std::exception& e) {
61974       {
61975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61976       };
61977     } catch (Dali::DaliException e) {
61978       {
61979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61980       };
61981     } catch (...) {
61982       {
61983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61984       };
61985     }
61986   }
61987
61988   jresult = result;
61989
61990   //argout typemap for const std::string&
61991
61992   return jresult;
61993 }
61994
61995
61996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
61997   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61998   Dali::Actor arg2 ;
61999   Dali::Actor *argp2 ;
62000
62001   arg1 = (Dali::Toolkit::Builder *)jarg1;
62002   argp2 = (Dali::Actor *)jarg2;
62003   if (!argp2) {
62004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62005     return ;
62006   }
62007   arg2 = *argp2;
62008   {
62009     try {
62010       (arg1)->AddActors(arg2);
62011     } catch (std::out_of_range& e) {
62012       {
62013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62014       };
62015     } catch (std::exception& e) {
62016       {
62017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62018       };
62019     } catch (Dali::DaliException e) {
62020       {
62021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62022       };
62023     } catch (...) {
62024       {
62025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62026       };
62027     }
62028   }
62029
62030 }
62031
62032
62033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62034   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62035   std::string *arg2 = 0 ;
62036   Dali::Actor arg3 ;
62037   Dali::Actor *argp3 ;
62038
62039   arg1 = (Dali::Toolkit::Builder *)jarg1;
62040   if (!jarg2) {
62041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62042     return ;
62043   }
62044   std::string arg2_str(jarg2);
62045   arg2 = &arg2_str;
62046   argp3 = (Dali::Actor *)jarg3;
62047   if (!argp3) {
62048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62049     return ;
62050   }
62051   arg3 = *argp3;
62052   {
62053     try {
62054       (arg1)->AddActors((std::string const &)*arg2,arg3);
62055     } catch (std::out_of_range& e) {
62056       {
62057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62058       };
62059     } catch (std::exception& e) {
62060       {
62061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62062       };
62063     } catch (Dali::DaliException e) {
62064       {
62065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62066       };
62067     } catch (...) {
62068       {
62069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62070       };
62071     }
62072   }
62073
62074
62075   //argout typemap for const std::string&
62076
62077 }
62078
62079
62080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62081   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62082   std::string *arg2 = 0 ;
62083
62084   arg1 = (Dali::Toolkit::Builder *)jarg1;
62085   if (!jarg2) {
62086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62087     return ;
62088   }
62089   std::string arg2_str(jarg2);
62090   arg2 = &arg2_str;
62091   {
62092     try {
62093       (arg1)->CreateRenderTask((std::string const &)*arg2);
62094     } catch (std::out_of_range& e) {
62095       {
62096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62097       };
62098     } catch (std::exception& e) {
62099       {
62100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62101       };
62102     } catch (Dali::DaliException e) {
62103       {
62104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62105       };
62106     } catch (...) {
62107       {
62108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62109       };
62110     }
62111   }
62112
62113
62114   //argout typemap for const std::string&
62115
62116 }
62117
62118
62119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62120   void * jresult ;
62121   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62122   std::string *arg2 = 0 ;
62123   Dali::Path result;
62124
62125   arg1 = (Dali::Toolkit::Builder *)jarg1;
62126   if (!jarg2) {
62127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62128     return 0;
62129   }
62130   std::string arg2_str(jarg2);
62131   arg2 = &arg2_str;
62132   {
62133     try {
62134       result = (arg1)->GetPath((std::string const &)*arg2);
62135     } catch (std::out_of_range& e) {
62136       {
62137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62138       };
62139     } catch (std::exception& e) {
62140       {
62141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62142       };
62143     } catch (Dali::DaliException e) {
62144       {
62145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62146       };
62147     } catch (...) {
62148       {
62149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62150       };
62151     }
62152   }
62153
62154   jresult = new Dali::Path((const Dali::Path &)result);
62155
62156   //argout typemap for const std::string&
62157
62158   return jresult;
62159 }
62160
62161
62162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62163   void * jresult ;
62164   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62165   std::string *arg2 = 0 ;
62166   Dali::PathConstrainer result;
62167
62168   arg1 = (Dali::Toolkit::Builder *)jarg1;
62169   if (!jarg2) {
62170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62171     return 0;
62172   }
62173   std::string arg2_str(jarg2);
62174   arg2 = &arg2_str;
62175   {
62176     try {
62177       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62178     } catch (std::out_of_range& e) {
62179       {
62180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62181       };
62182     } catch (std::exception& e) {
62183       {
62184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62185       };
62186     } catch (Dali::DaliException e) {
62187       {
62188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62189       };
62190     } catch (...) {
62191       {
62192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62193       };
62194     }
62195   }
62196
62197   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62198
62199   //argout typemap for const std::string&
62200
62201   return jresult;
62202 }
62203
62204
62205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62206   void * jresult ;
62207   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62208   std::string *arg2 = 0 ;
62209   Dali::LinearConstrainer result;
62210
62211   arg1 = (Dali::Toolkit::Builder *)jarg1;
62212   if (!jarg2) {
62213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62214     return 0;
62215   }
62216   std::string arg2_str(jarg2);
62217   arg2 = &arg2_str;
62218   {
62219     try {
62220       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62221     } catch (std::out_of_range& e) {
62222       {
62223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62224       };
62225     } catch (std::exception& e) {
62226       {
62227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62228       };
62229     } catch (Dali::DaliException e) {
62230       {
62231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62232       };
62233     } catch (...) {
62234       {
62235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62236       };
62237     }
62238   }
62239
62240   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62241
62242   //argout typemap for const std::string&
62243
62244   return jresult;
62245 }
62246
62247
62248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62249   void * jresult ;
62250   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62251   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62252
62253   arg1 = (Dali::Toolkit::Builder *)jarg1;
62254   {
62255     try {
62256       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62257     } catch (std::out_of_range& e) {
62258       {
62259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62260       };
62261     } catch (std::exception& e) {
62262       {
62263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62264       };
62265     } catch (Dali::DaliException e) {
62266       {
62267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62268       };
62269     } catch (...) {
62270       {
62271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62272       };
62273     }
62274   }
62275
62276   jresult = (void *)result;
62277   return jresult;
62278 }
62279
62280
62281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62282   void * jresult ;
62283   Dali::Toolkit::TransitionData *result = 0 ;
62284
62285   {
62286     try {
62287       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62288     } catch (std::out_of_range& e) {
62289       {
62290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62291       };
62292     } catch (std::exception& e) {
62293       {
62294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62295       };
62296     } catch (Dali::DaliException e) {
62297       {
62298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62299       };
62300     } catch (...) {
62301       {
62302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62303       };
62304     }
62305   }
62306
62307   jresult = (void *)result;
62308   return jresult;
62309 }
62310
62311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62312   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62313
62314   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62315   {
62316     try {
62317       delete arg1;
62318     } catch (std::out_of_range& e) {
62319       {
62320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62321       };
62322     } catch (std::exception& e) {
62323       {
62324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62325       };
62326     } catch (Dali::DaliException e) {
62327       {
62328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62329       };
62330     } catch (...) {
62331       {
62332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62333       };
62334     }
62335   }
62336
62337 }
62338
62339
62340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62341   void * jresult ;
62342   Dali::Property::Map *arg1 = 0 ;
62343   Dali::Toolkit::TransitionData result;
62344
62345   arg1 = (Dali::Property::Map *)jarg1;
62346   if (!arg1) {
62347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62348     return 0;
62349   }
62350   {
62351     try {
62352       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62353     } catch (std::out_of_range& e) {
62354       {
62355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62356       };
62357     } catch (std::exception& e) {
62358       {
62359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62360       };
62361     } catch (Dali::DaliException e) {
62362       {
62363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62364       };
62365     } catch (...) {
62366       {
62367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62368       };
62369     }
62370   }
62371
62372   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62373   return jresult;
62374 }
62375
62376
62377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62378   void * jresult ;
62379   Dali::Property::Array *arg1 = 0 ;
62380   Dali::Toolkit::TransitionData result;
62381
62382   arg1 = (Dali::Property::Array *)jarg1;
62383   if (!arg1) {
62384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62385     return 0;
62386   }
62387   {
62388     try {
62389       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62390     } catch (std::out_of_range& e) {
62391       {
62392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62393       };
62394     } catch (std::exception& e) {
62395       {
62396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62397       };
62398     } catch (Dali::DaliException e) {
62399       {
62400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62401       };
62402     } catch (...) {
62403       {
62404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62405       };
62406     }
62407   }
62408
62409   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62410   return jresult;
62411 }
62412
62413
62414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62415   void * jresult ;
62416   Dali::BaseHandle arg1 ;
62417   Dali::BaseHandle *argp1 ;
62418   Dali::Toolkit::TransitionData result;
62419
62420   argp1 = (Dali::BaseHandle *)jarg1;
62421   if (!argp1) {
62422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62423     return 0;
62424   }
62425   arg1 = *argp1;
62426   {
62427     try {
62428       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62429     } catch (std::out_of_range& e) {
62430       {
62431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62432       };
62433     } catch (std::exception& e) {
62434       {
62435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62436       };
62437     } catch (Dali::DaliException e) {
62438       {
62439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62440       };
62441     } catch (...) {
62442       {
62443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62444       };
62445     }
62446   }
62447
62448   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62449   return jresult;
62450 }
62451
62452
62453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62454   void * jresult ;
62455   Dali::Toolkit::TransitionData *arg1 = 0 ;
62456   Dali::Toolkit::TransitionData *result = 0 ;
62457
62458   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62459   if (!arg1) {
62460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62461     return 0;
62462   }
62463   {
62464     try {
62465       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62466     } catch (std::out_of_range& e) {
62467       {
62468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62469       };
62470     } catch (std::exception& e) {
62471       {
62472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62473       };
62474     } catch (Dali::DaliException e) {
62475       {
62476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62477       };
62478     } catch (...) {
62479       {
62480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62481       };
62482     }
62483   }
62484
62485   jresult = (void *)result;
62486   return jresult;
62487 }
62488
62489
62490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62491   void * jresult ;
62492   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62493   Dali::Toolkit::TransitionData *arg2 = 0 ;
62494   Dali::Toolkit::TransitionData *result = 0 ;
62495
62496   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62497   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62498   if (!arg2) {
62499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62500     return 0;
62501   }
62502   {
62503     try {
62504       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62505     } catch (std::out_of_range& e) {
62506       {
62507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62508       };
62509     } catch (std::exception& e) {
62510       {
62511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62512       };
62513     } catch (Dali::DaliException e) {
62514       {
62515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62516       };
62517     } catch (...) {
62518       {
62519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62520       };
62521     }
62522   }
62523
62524   jresult = (void *)result;
62525   return jresult;
62526 }
62527
62528
62529 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62530   unsigned long jresult ;
62531   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62532   size_t result;
62533
62534   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62535   {
62536     try {
62537       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62538     } catch (std::out_of_range& e) {
62539       {
62540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62541       };
62542     } catch (std::exception& e) {
62543       {
62544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62545       };
62546     } catch (Dali::DaliException e) {
62547       {
62548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62549       };
62550     } catch (...) {
62551       {
62552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62553       };
62554     }
62555   }
62556
62557   jresult = (unsigned long)result;
62558   return jresult;
62559 }
62560
62561
62562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62563   void * jresult ;
62564   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62565   size_t arg2 ;
62566   Dali::Property::Map result;
62567
62568   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62569   arg2 = (size_t)jarg2;
62570   {
62571     try {
62572       result = (arg1)->GetAnimatorAt(arg2);
62573     } catch (std::out_of_range& e) {
62574       {
62575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62576       };
62577     } catch (std::exception& e) {
62578       {
62579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62580       };
62581     } catch (Dali::DaliException e) {
62582       {
62583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62584       };
62585     } catch (...) {
62586       {
62587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62588       };
62589     }
62590   }
62591
62592   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62593   return jresult;
62594 }
62595
62596
62597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62598   int jresult ;
62599   int result;
62600
62601   {
62602     try {
62603       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62604     } catch (std::out_of_range& e) {
62605       {
62606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62607       };
62608     } catch (std::exception& e) {
62609       {
62610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62611       };
62612     } catch (Dali::DaliException e) {
62613       {
62614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62615       };
62616     } catch (...) {
62617       {
62618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62619       };
62620     }
62621   }
62622
62623   jresult = (int)result;
62624   return jresult;
62625 }
62626
62627
62628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62629   int jresult ;
62630   int result;
62631
62632   {
62633     try {
62634       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
62635     } catch (std::out_of_range& e) {
62636       {
62637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62638       };
62639     } catch (std::exception& e) {
62640       {
62641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62642       };
62643     } catch (Dali::DaliException e) {
62644       {
62645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62646       };
62647     } catch (...) {
62648       {
62649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62650       };
62651     }
62652   }
62653
62654   jresult = (int)result;
62655   return jresult;
62656 }
62657
62658
62659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
62660   int jresult ;
62661   int result;
62662
62663   {
62664     try {
62665       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
62666     } catch (std::out_of_range& e) {
62667       {
62668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62669       };
62670     } catch (std::exception& e) {
62671       {
62672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62673       };
62674     } catch (Dali::DaliException e) {
62675       {
62676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62677       };
62678     } catch (...) {
62679       {
62680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62681       };
62682     }
62683   }
62684
62685   jresult = (int)result;
62686   return jresult;
62687 }
62688
62689
62690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
62691   int jresult ;
62692   int result;
62693
62694   {
62695     try {
62696       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
62697     } catch (std::out_of_range& e) {
62698       {
62699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62700       };
62701     } catch (std::exception& e) {
62702       {
62703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62704       };
62705     } catch (Dali::DaliException e) {
62706       {
62707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62708       };
62709     } catch (...) {
62710       {
62711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62712       };
62713     }
62714   }
62715
62716   jresult = (int)result;
62717   return jresult;
62718 }
62719
62720
62721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
62722   int jresult ;
62723   int result;
62724
62725   {
62726     try {
62727       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
62728     } catch (std::out_of_range& e) {
62729       {
62730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62731       };
62732     } catch (std::exception& e) {
62733       {
62734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62735       };
62736     } catch (Dali::DaliException e) {
62737       {
62738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62739       };
62740     } catch (...) {
62741       {
62742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62743       };
62744     }
62745   }
62746
62747   jresult = (int)result;
62748   return jresult;
62749 }
62750
62751
62752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
62753   int jresult ;
62754   int result;
62755
62756   {
62757     try {
62758       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
62759     } catch (std::out_of_range& e) {
62760       {
62761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62762       };
62763     } catch (std::exception& e) {
62764       {
62765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62766       };
62767     } catch (Dali::DaliException e) {
62768       {
62769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62770       };
62771     } catch (...) {
62772       {
62773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62774       };
62775     }
62776   }
62777
62778   jresult = (int)result;
62779   return jresult;
62780 }
62781
62782
62783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
62784   int jresult ;
62785   int result;
62786
62787   {
62788     try {
62789       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
62790     } catch (std::out_of_range& e) {
62791       {
62792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62793       };
62794     } catch (std::exception& e) {
62795       {
62796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62797       };
62798     } catch (Dali::DaliException e) {
62799       {
62800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62801       };
62802     } catch (...) {
62803       {
62804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62805       };
62806     }
62807   }
62808
62809   jresult = (int)result;
62810   return jresult;
62811 }
62812
62813
62814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
62815   int jresult ;
62816   int result;
62817
62818   {
62819     try {
62820       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
62821     } catch (std::out_of_range& e) {
62822       {
62823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62824       };
62825     } catch (std::exception& e) {
62826       {
62827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62828       };
62829     } catch (Dali::DaliException e) {
62830       {
62831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62832       };
62833     } catch (...) {
62834       {
62835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62836       };
62837     }
62838   }
62839
62840   jresult = (int)result;
62841   return jresult;
62842 }
62843
62844
62845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
62846   int jresult ;
62847   int result;
62848
62849   {
62850     try {
62851       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
62852     } catch (std::out_of_range& e) {
62853       {
62854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62855       };
62856     } catch (std::exception& e) {
62857       {
62858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62859       };
62860     } catch (Dali::DaliException e) {
62861       {
62862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62863       };
62864     } catch (...) {
62865       {
62866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62867       };
62868     }
62869   }
62870
62871   jresult = (int)result;
62872   return jresult;
62873 }
62874
62875
62876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
62877   int jresult ;
62878   int result;
62879
62880   {
62881     try {
62882       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
62883     } catch (std::out_of_range& e) {
62884       {
62885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62886       };
62887     } catch (std::exception& e) {
62888       {
62889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62890       };
62891     } catch (Dali::DaliException e) {
62892       {
62893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62894       };
62895     } catch (...) {
62896       {
62897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62898       };
62899     }
62900   }
62901
62902   jresult = (int)result;
62903   return jresult;
62904 }
62905
62906
62907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
62908   int jresult ;
62909   int result;
62910
62911   {
62912     try {
62913       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
62914     } catch (std::out_of_range& e) {
62915       {
62916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62917       };
62918     } catch (std::exception& e) {
62919       {
62920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62921       };
62922     } catch (Dali::DaliException e) {
62923       {
62924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62925       };
62926     } catch (...) {
62927       {
62928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62929       };
62930     }
62931   }
62932
62933   jresult = (int)result;
62934   return jresult;
62935 }
62936
62937
62938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
62939   int jresult ;
62940   int result;
62941
62942   {
62943     try {
62944       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
62945     } catch (std::out_of_range& e) {
62946       {
62947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62948       };
62949     } catch (std::exception& e) {
62950       {
62951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62952       };
62953     } catch (Dali::DaliException e) {
62954       {
62955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62956       };
62957     } catch (...) {
62958       {
62959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62960       };
62961     }
62962   }
62963
62964   jresult = (int)result;
62965   return jresult;
62966 }
62967
62968
62969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
62970   int jresult ;
62971   int result;
62972
62973   {
62974     try {
62975       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
62976     } catch (std::out_of_range& e) {
62977       {
62978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62979       };
62980     } catch (std::exception& e) {
62981       {
62982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62983       };
62984     } catch (Dali::DaliException e) {
62985       {
62986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62987       };
62988     } catch (...) {
62989       {
62990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62991       };
62992     }
62993   }
62994
62995   jresult = (int)result;
62996   return jresult;
62997 }
62998
62999
63000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
63001   int jresult ;
63002   int result;
63003
63004   {
63005     try {
63006       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
63007     } catch (std::out_of_range& e) {
63008       {
63009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63010       };
63011     } catch (std::exception& e) {
63012       {
63013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63014       };
63015     } catch (Dali::DaliException e) {
63016       {
63017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63018       };
63019     } catch (...) {
63020       {
63021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63022       };
63023     }
63024   }
63025
63026   jresult = (int)result;
63027   return jresult;
63028 }
63029
63030
63031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
63032   void * jresult ;
63033   Dali::Toolkit::Control result;
63034
63035   {
63036     try {
63037       result = Dali::Toolkit::Internal::Control::New();
63038     } catch (std::out_of_range& e) {
63039       {
63040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63041       };
63042     } catch (std::exception& e) {
63043       {
63044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63045       };
63046     } catch (Dali::DaliException e) {
63047       {
63048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63049       };
63050     } catch (...) {
63051       {
63052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63053       };
63054     }
63055   }
63056
63057   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63058   return jresult;
63059 }
63060
63061
63062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
63063   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63064   std::string *arg2 = 0 ;
63065
63066   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63067   if (!jarg2) {
63068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63069     return ;
63070   }
63071   std::string arg2_str(jarg2);
63072   arg2 = &arg2_str;
63073   {
63074     try {
63075       (arg1)->SetStyleName((std::string const &)*arg2);
63076     } catch (std::out_of_range& e) {
63077       {
63078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63079       };
63080     } catch (std::exception& e) {
63081       {
63082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63083       };
63084     } catch (Dali::DaliException e) {
63085       {
63086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63087       };
63088     } catch (...) {
63089       {
63090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63091       };
63092     }
63093   }
63094
63095
63096   //argout typemap for const std::string&
63097
63098 }
63099
63100
63101 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63102   char * jresult ;
63103   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63104   std::string *result = 0 ;
63105
63106   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63107   {
63108     try {
63109       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63110     } catch (std::out_of_range& e) {
63111       {
63112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63113       };
63114     } catch (std::exception& e) {
63115       {
63116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63117       };
63118     } catch (Dali::DaliException e) {
63119       {
63120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63121       };
63122     } catch (...) {
63123       {
63124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63125       };
63126     }
63127   }
63128
63129   jresult = SWIG_csharp_string_callback(result->c_str());
63130   return jresult;
63131 }
63132
63133
63134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63135   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63136   Dali::Vector4 *arg2 = 0 ;
63137
63138   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63139   arg2 = (Dali::Vector4 *)jarg2;
63140   if (!arg2) {
63141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63142     return ;
63143   }
63144   {
63145     try {
63146       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63147     } catch (std::out_of_range& e) {
63148       {
63149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63150       };
63151     } catch (std::exception& e) {
63152       {
63153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63154       };
63155     } catch (Dali::DaliException e) {
63156       {
63157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63158       };
63159     } catch (...) {
63160       {
63161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63162       };
63163     }
63164   }
63165
63166 }
63167
63168
63169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63170   void * jresult ;
63171   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
63172   Dali::Vector4 result;
63173
63174   arg1 = (Dali::Handle *)jarg1;
63175   {
63176     try {
63177       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
63178       if (resultMap)
63179       {
63180         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
63181         if(type && type->Get<int>() == Visual::COLOR )
63182         {
63183           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
63184           if (value)
63185           {
63186             result = value->Get<Vector4>();
63187           }
63188         }
63189       }
63190     } catch (std::out_of_range& e) {
63191       {
63192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63193       };
63194     } catch (std::exception& e) {
63195       {
63196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63197       };
63198     } catch (Dali::DaliException e) {
63199       {
63200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63201       };
63202     } catch (...) {
63203       {
63204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63205       };
63206     }
63207   }
63208
63209   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63210   return jresult;
63211 }
63212
63213
63214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63215   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63216   Dali::Property::Map *arg2 = 0 ;
63217
63218   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63219   arg2 = (Dali::Property::Map *)jarg2;
63220   if (!arg2) {
63221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63222     return ;
63223   }
63224   {
63225     try {
63226       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63227     } catch (std::out_of_range& e) {
63228       {
63229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63230       };
63231     } catch (std::exception& e) {
63232       {
63233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63234       };
63235     } catch (Dali::DaliException e) {
63236       {
63237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63238       };
63239     } catch (...) {
63240       {
63241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63242       };
63243     }
63244   }
63245
63246 }
63247
63248
63249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63250   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63251
63252   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63253   {
63254     try {
63255       (arg1)->ClearBackground();
63256     } catch (std::out_of_range& e) {
63257       {
63258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63259       };
63260     } catch (std::exception& e) {
63261       {
63262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63263       };
63264     } catch (Dali::DaliException e) {
63265       {
63266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63267       };
63268     } catch (...) {
63269       {
63270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63271       };
63272     }
63273   }
63274
63275 }
63276
63277
63278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63279   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63280   Dali::Gesture::Type arg2 ;
63281
63282   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63283   arg2 = (Dali::Gesture::Type)jarg2;
63284   {
63285     try {
63286       (arg1)->EnableGestureDetection(arg2);
63287     } catch (std::out_of_range& e) {
63288       {
63289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63290       };
63291     } catch (std::exception& e) {
63292       {
63293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63294       };
63295     } catch (Dali::DaliException e) {
63296       {
63297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63298       };
63299     } catch (...) {
63300       {
63301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63302       };
63303     }
63304   }
63305
63306 }
63307
63308
63309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63310   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63311   Dali::Gesture::Type arg2 ;
63312
63313   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63314   arg2 = (Dali::Gesture::Type)jarg2;
63315   {
63316     try {
63317       (arg1)->DisableGestureDetection(arg2);
63318     } catch (std::out_of_range& e) {
63319       {
63320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63321       };
63322     } catch (std::exception& e) {
63323       {
63324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63325       };
63326     } catch (Dali::DaliException e) {
63327       {
63328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63329       };
63330     } catch (...) {
63331       {
63332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63333       };
63334     }
63335   }
63336
63337 }
63338
63339
63340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63341   void * jresult ;
63342   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63343   Dali::PinchGestureDetector result;
63344
63345   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63346   {
63347     try {
63348       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63349     } catch (std::out_of_range& e) {
63350       {
63351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63352       };
63353     } catch (std::exception& e) {
63354       {
63355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63356       };
63357     } catch (Dali::DaliException e) {
63358       {
63359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63360       };
63361     } catch (...) {
63362       {
63363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63364       };
63365     }
63366   }
63367
63368   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63369   return jresult;
63370 }
63371
63372
63373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63374   void * jresult ;
63375   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63376   Dali::PanGestureDetector result;
63377
63378   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63379   {
63380     try {
63381       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63382     } catch (std::out_of_range& e) {
63383       {
63384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63385       };
63386     } catch (std::exception& e) {
63387       {
63388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63389       };
63390     } catch (Dali::DaliException e) {
63391       {
63392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63393       };
63394     } catch (...) {
63395       {
63396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63397       };
63398     }
63399   }
63400
63401   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63402   return jresult;
63403 }
63404
63405
63406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63407   void * jresult ;
63408   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63409   Dali::TapGestureDetector result;
63410
63411   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63412   {
63413     try {
63414       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63415     } catch (std::out_of_range& e) {
63416       {
63417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63418       };
63419     } catch (std::exception& e) {
63420       {
63421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63422       };
63423     } catch (Dali::DaliException e) {
63424       {
63425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63426       };
63427     } catch (...) {
63428       {
63429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63430       };
63431     }
63432   }
63433
63434   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63435   return jresult;
63436 }
63437
63438
63439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63440   void * jresult ;
63441   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63442   Dali::LongPressGestureDetector result;
63443
63444   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63445   {
63446     try {
63447       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63448     } catch (std::out_of_range& e) {
63449       {
63450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63451       };
63452     } catch (std::exception& e) {
63453       {
63454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63455       };
63456     } catch (Dali::DaliException e) {
63457       {
63458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63459       };
63460     } catch (...) {
63461       {
63462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63463       };
63464     }
63465   }
63466
63467   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63468   return jresult;
63469 }
63470
63471
63472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63473   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63474   bool arg2 ;
63475
63476   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63477   arg2 = jarg2 ? true : false;
63478   {
63479     try {
63480       (arg1)->SetKeyboardNavigationSupport(arg2);
63481     } catch (std::out_of_range& e) {
63482       {
63483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63484       };
63485     } catch (std::exception& e) {
63486       {
63487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63488       };
63489     } catch (Dali::DaliException e) {
63490       {
63491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63492       };
63493     } catch (...) {
63494       {
63495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63496       };
63497     }
63498   }
63499
63500 }
63501
63502
63503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63504   unsigned int jresult ;
63505   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63506   bool result;
63507
63508   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63509   {
63510     try {
63511       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63512     } catch (std::out_of_range& e) {
63513       {
63514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63515       };
63516     } catch (std::exception& e) {
63517       {
63518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63519       };
63520     } catch (Dali::DaliException e) {
63521       {
63522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63523       };
63524     } catch (...) {
63525       {
63526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63527       };
63528     }
63529   }
63530
63531   jresult = result;
63532   return jresult;
63533 }
63534
63535
63536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63537   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63538
63539   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63540   {
63541     try {
63542       (arg1)->SetKeyInputFocus();
63543     } catch (std::out_of_range& e) {
63544       {
63545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63546       };
63547     } catch (std::exception& e) {
63548       {
63549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63550       };
63551     } catch (Dali::DaliException e) {
63552       {
63553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63554       };
63555     } catch (...) {
63556       {
63557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63558       };
63559     }
63560   }
63561
63562 }
63563
63564
63565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63566   unsigned int jresult ;
63567   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63568   bool result;
63569
63570   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63571   {
63572     try {
63573       result = (bool)(arg1)->HasKeyInputFocus();
63574     } catch (std::out_of_range& e) {
63575       {
63576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63577       };
63578     } catch (std::exception& e) {
63579       {
63580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63581       };
63582     } catch (Dali::DaliException e) {
63583       {
63584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63585       };
63586     } catch (...) {
63587       {
63588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63589       };
63590     }
63591   }
63592
63593   jresult = result;
63594   return jresult;
63595 }
63596
63597
63598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
63599   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63600
63601   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63602   {
63603     try {
63604       (arg1)->ClearKeyInputFocus();
63605     } catch (std::out_of_range& e) {
63606       {
63607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63608       };
63609     } catch (std::exception& e) {
63610       {
63611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63612       };
63613     } catch (Dali::DaliException e) {
63614       {
63615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63616       };
63617     } catch (...) {
63618       {
63619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63620       };
63621     }
63622   }
63623
63624 }
63625
63626
63627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
63628   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63629   bool arg2 ;
63630
63631   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63632   arg2 = jarg2 ? true : false;
63633   {
63634     try {
63635       (arg1)->SetAsKeyboardFocusGroup(arg2);
63636     } catch (std::out_of_range& e) {
63637       {
63638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63639       };
63640     } catch (std::exception& e) {
63641       {
63642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63643       };
63644     } catch (Dali::DaliException e) {
63645       {
63646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63647       };
63648     } catch (...) {
63649       {
63650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63651       };
63652     }
63653   }
63654
63655 }
63656
63657
63658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
63659   unsigned int jresult ;
63660   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63661   bool result;
63662
63663   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63664   {
63665     try {
63666       result = (bool)(arg1)->IsKeyboardFocusGroup();
63667     } catch (std::out_of_range& e) {
63668       {
63669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63670       };
63671     } catch (std::exception& e) {
63672       {
63673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63674       };
63675     } catch (Dali::DaliException e) {
63676       {
63677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63678       };
63679     } catch (...) {
63680       {
63681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63682       };
63683     }
63684   }
63685
63686   jresult = result;
63687   return jresult;
63688 }
63689
63690
63691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
63692   void * jresult ;
63693   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63694   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63695
63696   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63697   {
63698     try {
63699       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63700     } catch (std::out_of_range& e) {
63701       {
63702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63703       };
63704     } catch (std::exception& e) {
63705       {
63706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63707       };
63708     } catch (Dali::DaliException e) {
63709       {
63710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63711       };
63712     } catch (...) {
63713       {
63714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63715       };
63716     }
63717   }
63718
63719   jresult = (void *)result;
63720   return jresult;
63721 }
63722
63723
63724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
63725   void * jresult ;
63726   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63727   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63728
63729   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63730   {
63731     try {
63732       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63733     } catch (std::out_of_range& e) {
63734       {
63735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63736       };
63737     } catch (std::exception& e) {
63738       {
63739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63740       };
63741     } catch (Dali::DaliException e) {
63742       {
63743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63744       };
63745     } catch (...) {
63746       {
63747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63748       };
63749     }
63750   }
63751
63752   jresult = (void *)result;
63753   return jresult;
63754 }
63755
63756
63757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
63758   void * jresult ;
63759   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63760   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63761
63762   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63763   {
63764     try {
63765       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63766     } catch (std::out_of_range& e) {
63767       {
63768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63769       };
63770     } catch (std::exception& e) {
63771       {
63772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63773       };
63774     } catch (Dali::DaliException e) {
63775       {
63776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63777       };
63778     } catch (...) {
63779       {
63780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63781       };
63782     }
63783   }
63784
63785   jresult = (void *)result;
63786   return jresult;
63787 }
63788
63789
63790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
63791   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63792   int arg2 ;
63793   SwigDirector_ViewImpl *darg = 0;
63794
63795   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63796   arg2 = (int)jarg2;
63797   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63798   if(!darg) {
63799     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63800     return;
63801   }
63802   {
63803     try {
63804       if(darg) {
63805         (darg)->OnStageConnection(arg2);
63806       }
63807     } catch (std::out_of_range& e) {
63808       {
63809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63810       };
63811     } catch (std::exception& e) {
63812       {
63813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63814       };
63815     } catch (Dali::DaliException e) {
63816       {
63817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63818       };
63819     } catch (...) {
63820       {
63821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63822       };
63823     }
63824   }
63825
63826 }
63827
63828
63829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
63830   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63831   int arg2 ;
63832   SwigDirector_ViewImpl *darg = 0;
63833
63834   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63835   arg2 = (int)jarg2;
63836   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63837   if(!darg) {
63838     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63839     return;
63840   }
63841   {
63842     try {
63843       if(darg) {
63844         (darg)->OnStageConnectionSwigPublic(arg2);
63845       }
63846     } catch (std::out_of_range& e) {
63847       {
63848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63849       };
63850     } catch (std::exception& e) {
63851       {
63852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63853       };
63854     } catch (Dali::DaliException e) {
63855       {
63856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63857       };
63858     } catch (...) {
63859       {
63860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63861       };
63862     }
63863   }
63864
63865 }
63866
63867
63868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
63869   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63870   SwigDirector_ViewImpl *darg = 0;
63871
63872   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63873   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63874   if(!darg) {
63875     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63876     return;
63877   }
63878   {
63879     try {
63880       if(darg) {
63881         (darg)->OnStageDisconnection();
63882       }
63883     } catch (std::out_of_range& e) {
63884       {
63885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63886       };
63887     } catch (std::exception& e) {
63888       {
63889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63890       };
63891     } catch (Dali::DaliException e) {
63892       {
63893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63894       };
63895     } catch (...) {
63896       {
63897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63898       };
63899     }
63900   }
63901
63902 }
63903
63904
63905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
63906   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63907   SwigDirector_ViewImpl *darg = 0;
63908
63909   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63910   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63911   if(!darg) {
63912     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63913     return;
63914   }
63915   {
63916     try {
63917       if(darg) {
63918         (darg)->OnStageDisconnectionSwigPublic();
63919       }
63920     } catch (std::out_of_range& e) {
63921       {
63922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63923       };
63924     } catch (std::exception& e) {
63925       {
63926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63927       };
63928     } catch (Dali::DaliException e) {
63929       {
63930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63931       };
63932     } catch (...) {
63933       {
63934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63935       };
63936     }
63937   }
63938
63939 }
63940
63941
63942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
63943   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63944   Dali::Actor *arg2 = 0 ;
63945   SwigDirector_ViewImpl *darg = 0;
63946
63947   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63948   arg2 = (Dali::Actor *)jarg2;
63949   if (!arg2) {
63950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63951     return ;
63952   }
63953   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63954   if(!darg) {
63955     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63956     return;
63957   }
63958   {
63959     try {
63960       if(darg) {
63961         (darg)->OnChildAdd(*arg2);
63962       }
63963     } catch (std::out_of_range& e) {
63964       {
63965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63966       };
63967     } catch (std::exception& e) {
63968       {
63969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63970       };
63971     } catch (Dali::DaliException e) {
63972       {
63973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63974       };
63975     } catch (...) {
63976       {
63977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63978       };
63979     }
63980   }
63981
63982 }
63983
63984
63985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63986   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63987   Dali::Actor *arg2 = 0 ;
63988   SwigDirector_ViewImpl *darg = 0;
63989
63990   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63991   arg2 = (Dali::Actor *)jarg2;
63992   if (!arg2) {
63993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63994     return ;
63995   }
63996   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63997   if(!darg) {
63998     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63999     return;
64000   }
64001   {
64002     try {
64003       if(darg) {
64004           (darg)->OnChildAddSwigPublic(*arg2);
64005       }
64006     } catch (std::out_of_range& e) {
64007       {
64008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64009       };
64010     } catch (std::exception& e) {
64011       {
64012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64013       };
64014     } catch (Dali::DaliException e) {
64015       {
64016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64017       };
64018     } catch (...) {
64019       {
64020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64021       };
64022     }
64023   }
64024
64025 }
64026
64027
64028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
64029   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64030   Dali::Actor *arg2 = 0 ;
64031   SwigDirector_ViewImpl *darg = 0;
64032
64033   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64034   arg2 = (Dali::Actor *)jarg2;
64035   if (!arg2) {
64036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64037     return ;
64038   }
64039   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64040   if(!darg) {
64041     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64042     return;
64043   }
64044   {
64045     try {
64046       if(darg) {
64047         (darg)->OnChildRemove(*arg2);
64048       }
64049     } catch (std::out_of_range& e) {
64050       {
64051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64052       };
64053     } catch (std::exception& e) {
64054       {
64055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64056       };
64057     } catch (Dali::DaliException e) {
64058       {
64059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64060       };
64061     } catch (...) {
64062       {
64063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64064       };
64065     }
64066   }
64067
64068 }
64069
64070
64071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64072   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64073   Dali::Actor *arg2 = 0 ;
64074   SwigDirector_ViewImpl *darg = 0;
64075
64076   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64077   arg2 = (Dali::Actor *)jarg2;
64078   if (!arg2) {
64079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64080     return ;
64081   }
64082   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64083   if(!darg) {
64084     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64085     return;
64086   }
64087   {
64088     try {
64089       if(darg) {
64090         (darg)->OnChildRemoveSwigPublic(*arg2);
64091       }
64092     } catch (std::out_of_range& e) {
64093       {
64094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64095       };
64096     } catch (std::exception& e) {
64097       {
64098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64099       };
64100     } catch (Dali::DaliException e) {
64101       {
64102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64103       };
64104     } catch (...) {
64105       {
64106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64107       };
64108     }
64109   }
64110
64111 }
64112
64113
64114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64115   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64116   Dali::Property::Index arg2 ;
64117   Dali::Property::Value arg3 ;
64118   Dali::Property::Value *argp3 ;
64119   SwigDirector_ViewImpl *darg = 0;
64120
64121   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64122   arg2 = (Dali::Property::Index)jarg2;
64123   argp3 = (Dali::Property::Value *)jarg3;
64124   if (!argp3) {
64125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64126     return ;
64127   }
64128   arg3 = *argp3;
64129   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64130   if (!darg) {
64131     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64132     return;
64133   }
64134   {
64135     try {
64136       (darg)->OnPropertySet(arg2,arg3);
64137     } catch (std::out_of_range& e) {
64138       {
64139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64140       };
64141     } catch (std::exception& e) {
64142       {
64143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64144       };
64145     } catch (Dali::DaliException e) {
64146       {
64147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64148       };
64149     } catch (...) {
64150       {
64151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64152       };
64153     }
64154   }
64155
64156 }
64157
64158
64159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64160   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64161   Dali::Property::Index arg2 ;
64162   Dali::Property::Value arg3 ;
64163   Dali::Property::Value *argp3 ;
64164   SwigDirector_ViewImpl *darg = 0;
64165
64166   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64167   arg2 = (Dali::Property::Index)jarg2;
64168   argp3 = (Dali::Property::Value *)jarg3;
64169   if (!argp3) {
64170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64171     return ;
64172   }
64173   arg3 = *argp3;
64174   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64175   if (!darg) {
64176     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64177     return;
64178   }
64179   {
64180     try {
64181       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64182     } catch (std::out_of_range& e) {
64183       {
64184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64185       };
64186     } catch (std::exception& e) {
64187       {
64188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64189       };
64190     } catch (Dali::DaliException e) {
64191       {
64192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64193       };
64194     } catch (...) {
64195       {
64196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64197       };
64198     }
64199   }
64200
64201 }
64202
64203
64204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64205   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64206   Dali::Vector3 *arg2 = 0 ;
64207   SwigDirector_ViewImpl *darg = 0;
64208
64209   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64210   arg2 = (Dali::Vector3 *)jarg2;
64211   if (!arg2) {
64212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64213     return ;
64214   }
64215   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64216   if (!darg) {
64217     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64218     return;
64219   }
64220   {
64221     try {
64222       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64223     } catch (std::out_of_range& e) {
64224       {
64225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64226       };
64227     } catch (std::exception& e) {
64228       {
64229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64230       };
64231     } catch (Dali::DaliException e) {
64232       {
64233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64234       };
64235     } catch (...) {
64236       {
64237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64238       };
64239     }
64240   }
64241
64242 }
64243
64244
64245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64246   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64247   Dali::Vector3 *arg2 = 0 ;
64248   SwigDirector_ViewImpl *darg = 0;
64249
64250   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64251   arg2 = (Dali::Vector3 *)jarg2;
64252   if (!arg2) {
64253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64254     return ;
64255   }
64256   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64257   if (!darg) {
64258     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64259     return;
64260   }
64261   {
64262     try {
64263       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64264     } catch (std::out_of_range& e) {
64265       {
64266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64267       };
64268     } catch (std::exception& e) {
64269       {
64270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64271       };
64272     } catch (Dali::DaliException e) {
64273       {
64274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64275       };
64276     } catch (...) {
64277       {
64278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64279       };
64280     }
64281   }
64282
64283 }
64284
64285
64286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64287   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64288   Dali::Animation *arg2 = 0 ;
64289   Dali::Vector3 *arg3 = 0 ;
64290   SwigDirector_ViewImpl *darg = 0;
64291
64292   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64293   arg2 = (Dali::Animation *)jarg2;
64294   if (!arg2) {
64295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64296     return ;
64297   }
64298   arg3 = (Dali::Vector3 *)jarg3;
64299   if (!arg3) {
64300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64301     return ;
64302   }
64303   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64304   if (!darg) {
64305     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64306     return;
64307   }
64308   {
64309     try {
64310       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64311     } catch (std::out_of_range& e) {
64312       {
64313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64314       };
64315     } catch (std::exception& e) {
64316       {
64317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64318       };
64319     } catch (Dali::DaliException e) {
64320       {
64321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64322       };
64323     } catch (...) {
64324       {
64325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64326       };
64327     }
64328   }
64329
64330 }
64331
64332
64333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64334   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64335   Dali::Animation *arg2 = 0 ;
64336   Dali::Vector3 *arg3 = 0 ;
64337   SwigDirector_ViewImpl *darg = 0;
64338
64339   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64340   arg2 = (Dali::Animation *)jarg2;
64341   if (!arg2) {
64342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64343     return ;
64344   }
64345   arg3 = (Dali::Vector3 *)jarg3;
64346   if (!arg3) {
64347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64348     return ;
64349   }
64350   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64351   if (!darg) {
64352     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64353     return;
64354   }
64355   {
64356     try {
64357       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64358     } catch (std::out_of_range& e) {
64359       {
64360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64361       };
64362     } catch (std::exception& e) {
64363       {
64364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64365       };
64366     } catch (Dali::DaliException e) {
64367       {
64368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64369       };
64370     } catch (...) {
64371       {
64372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64373       };
64374     }
64375   }
64376
64377 }
64378
64379
64380 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64381   unsigned int jresult ;
64382   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64383   Dali::TouchEvent *arg2 = 0 ;
64384   SwigDirector_ViewImpl *darg = 0;
64385   bool result;
64386
64387   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64388   arg2 = (Dali::TouchEvent *)jarg2;
64389   if (!arg2) {
64390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64391     return 0;
64392   }
64393   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64394   if (!darg) {
64395     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64396     return 0;
64397   }
64398   {
64399     try {
64400       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64401     } catch (std::out_of_range& e) {
64402       {
64403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64404       };
64405     } catch (std::exception& e) {
64406       {
64407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64408       };
64409     } catch (Dali::DaliException e) {
64410       {
64411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64412       };
64413     } catch (...) {
64414       {
64415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64416       };
64417     }
64418   }
64419
64420   jresult = result;
64421   return jresult;
64422 }
64423
64424
64425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64426   unsigned int jresult ;
64427   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64428   Dali::TouchEvent *arg2 = 0 ;
64429   SwigDirector_ViewImpl *darg = 0;
64430   bool result;
64431
64432   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64433   arg2 = (Dali::TouchEvent *)jarg2;
64434   if (!arg2) {
64435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64436     return 0;
64437   }
64438   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64439   if (!darg) {
64440     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64441     return 0;
64442   }
64443   {
64444     try {
64445       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64446     } catch (std::out_of_range& e) {
64447       {
64448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64449       };
64450     } catch (std::exception& e) {
64451       {
64452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64453       };
64454     } catch (Dali::DaliException e) {
64455       {
64456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64457       };
64458     } catch (...) {
64459       {
64460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64461       };
64462     }
64463   }
64464
64465   jresult = result;
64466   return jresult;
64467 }
64468
64469
64470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64471   unsigned int jresult ;
64472   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64473   Dali::HoverEvent *arg2 = 0 ;
64474   SwigDirector_ViewImpl *darg = 0;
64475   bool result;
64476
64477   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64478   arg2 = (Dali::HoverEvent *)jarg2;
64479   if (!arg2) {
64480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64481     return 0;
64482   }
64483   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64484   if (!darg) {
64485     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64486     return 0;
64487   }
64488   {
64489     try {
64490       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64491     } catch (std::out_of_range& e) {
64492       {
64493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64494       };
64495     } catch (std::exception& e) {
64496       {
64497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64498       };
64499     } catch (Dali::DaliException e) {
64500       {
64501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64502       };
64503     } catch (...) {
64504       {
64505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64506       };
64507     }
64508   }
64509
64510   jresult = result;
64511   return jresult;
64512 }
64513
64514
64515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64516   unsigned int jresult ;
64517   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64518   Dali::HoverEvent *arg2 = 0 ;
64519   SwigDirector_ViewImpl *darg = 0;
64520   bool result;
64521
64522   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64523   arg2 = (Dali::HoverEvent *)jarg2;
64524   if (!arg2) {
64525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64526     return 0;
64527   }
64528   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64529   if (!darg) {
64530     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64531     return 0;
64532   }
64533   {
64534     try {
64535       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64536     } catch (std::out_of_range& e) {
64537       {
64538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64539       };
64540     } catch (std::exception& e) {
64541       {
64542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64543       };
64544     } catch (Dali::DaliException e) {
64545       {
64546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64547       };
64548     } catch (...) {
64549       {
64550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64551       };
64552     }
64553   }
64554
64555   jresult = result;
64556   return jresult;
64557 }
64558
64559
64560 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64561   unsigned int jresult ;
64562   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64563   Dali::KeyEvent *arg2 = 0 ;
64564   SwigDirector_ViewImpl *darg = 0;
64565   bool result;
64566
64567   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64568   arg2 = (Dali::KeyEvent *)jarg2;
64569   if (!arg2) {
64570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64571     return 0;
64572   }
64573   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64574   if (!darg) {
64575     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64576     return 0;
64577   }
64578   {
64579     try {
64580       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64581     } catch (std::out_of_range& e) {
64582       {
64583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64584       };
64585     } catch (std::exception& e) {
64586       {
64587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64588       };
64589     } catch (Dali::DaliException e) {
64590       {
64591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64592       };
64593     } catch (...) {
64594       {
64595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64596       };
64597     }
64598   }
64599
64600   jresult = result;
64601   return jresult;
64602 }
64603
64604
64605 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64606   unsigned int jresult ;
64607   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64608   Dali::KeyEvent *arg2 = 0 ;
64609   SwigDirector_ViewImpl *darg = 0;
64610   bool result;
64611
64612   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64613   arg2 = (Dali::KeyEvent *)jarg2;
64614   if (!arg2) {
64615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64616     return 0;
64617   }
64618   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64619   if (!darg) {
64620     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64621     return 0;
64622   }
64623   {
64624     try {
64625       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
64626     } catch (std::out_of_range& e) {
64627       {
64628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64629       };
64630     } catch (std::exception& e) {
64631       {
64632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64633       };
64634     } catch (Dali::DaliException e) {
64635       {
64636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64637       };
64638     } catch (...) {
64639       {
64640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64641       };
64642     }
64643   }
64644
64645   jresult = result;
64646   return jresult;
64647 }
64648
64649
64650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
64651   unsigned int jresult ;
64652   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64653   Dali::WheelEvent *arg2 = 0 ;
64654   SwigDirector_ViewImpl *darg = 0;
64655   bool result;
64656
64657   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64658   arg2 = (Dali::WheelEvent *)jarg2;
64659   if (!arg2) {
64660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64661     return 0;
64662   }
64663   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64664   if (!darg) {
64665     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64666     return 0;
64667   }
64668   {
64669     try {
64670       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
64671     } catch (std::out_of_range& e) {
64672       {
64673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64674       };
64675     } catch (std::exception& e) {
64676       {
64677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64678       };
64679     } catch (Dali::DaliException e) {
64680       {
64681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64682       };
64683     } catch (...) {
64684       {
64685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64686       };
64687     }
64688   }
64689
64690   jresult = result;
64691   return jresult;
64692 }
64693
64694
64695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64696   unsigned int jresult ;
64697   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64698   Dali::WheelEvent *arg2 = 0 ;
64699   SwigDirector_ViewImpl *darg = 0;
64700   bool result;
64701
64702   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64703   arg2 = (Dali::WheelEvent *)jarg2;
64704   if (!arg2) {
64705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64706     return 0;
64707   }
64708   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64709   if (!darg) {
64710     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64711     return 0;
64712   }
64713   {
64714     try {
64715       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
64716     } catch (std::out_of_range& e) {
64717       {
64718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64719       };
64720     } catch (std::exception& e) {
64721       {
64722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64723       };
64724     } catch (Dali::DaliException e) {
64725       {
64726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64727       };
64728     } catch (...) {
64729       {
64730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64731       };
64732     }
64733   }
64734
64735   jresult = result;
64736   return jresult;
64737 }
64738
64739
64740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
64741   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64742   Dali::Vector2 *arg2 = 0 ;
64743   Dali::RelayoutContainer *arg3 = 0 ;
64744   SwigDirector_ViewImpl *darg = 0;
64745
64746   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64747   arg2 = (Dali::Vector2 *)jarg2;
64748   if (!arg2) {
64749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64750     return ;
64751   }
64752   arg3 = (Dali::RelayoutContainer *)jarg3;
64753   if (!arg3) {
64754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64755     return ;
64756   }
64757   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64758   if (!darg) {
64759     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64760     return;
64761   }
64762   {
64763     try {
64764       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
64765     } catch (std::out_of_range& e) {
64766       {
64767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64768       };
64769     } catch (std::exception& e) {
64770       {
64771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64772       };
64773     } catch (Dali::DaliException e) {
64774       {
64775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64776       };
64777     } catch (...) {
64778       {
64779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64780       };
64781     }
64782   }
64783
64784 }
64785
64786
64787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64788   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64789   Dali::Vector2 *arg2 = 0 ;
64790   Dali::RelayoutContainer *arg3 = 0 ;
64791   SwigDirector_ViewImpl *darg = 0;
64792
64793   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64794   arg2 = (Dali::Vector2 *)jarg2;
64795   if (!arg2) {
64796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64797     return ;
64798   }
64799   arg3 = (Dali::RelayoutContainer *)jarg3;
64800   if (!arg3) {
64801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64802     return ;
64803   }
64804   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64805   if (!darg) {
64806     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64807     return;
64808   }
64809   {
64810     try {
64811       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
64812     } catch (std::out_of_range& e) {
64813       {
64814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64815       };
64816     } catch (std::exception& e) {
64817       {
64818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64819       };
64820     } catch (Dali::DaliException e) {
64821       {
64822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64823       };
64824     } catch (...) {
64825       {
64826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64827       };
64828     }
64829   }
64830
64831 }
64832
64833
64834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
64835   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64836   Dali::ResizePolicy::Type arg2 ;
64837   Dali::Dimension::Type arg3 ;
64838   SwigDirector_ViewImpl *darg = 0;
64839
64840   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64841   arg2 = (Dali::ResizePolicy::Type)jarg2;
64842   arg3 = (Dali::Dimension::Type)jarg3;
64843   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64844   if (!darg) {
64845     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64846     return;
64847   }
64848   {
64849     try {
64850       (darg)->OnSetResizePolicy(arg2,arg3);
64851     } catch (std::out_of_range& e) {
64852       {
64853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64854       };
64855     } catch (std::exception& e) {
64856       {
64857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64858       };
64859     } catch (Dali::DaliException e) {
64860       {
64861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64862       };
64863     } catch (...) {
64864       {
64865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64866       };
64867     }
64868   }
64869
64870 }
64871
64872
64873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
64874   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64875   Dali::ResizePolicy::Type arg2 ;
64876   Dali::Dimension::Type arg3 ;
64877   SwigDirector_ViewImpl *darg = 0;
64878
64879   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64880   arg2 = (Dali::ResizePolicy::Type)jarg2;
64881   arg3 = (Dali::Dimension::Type)jarg3;
64882   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64883   if (!darg) {
64884     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64885     return;
64886   }
64887   {
64888     try {
64889       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
64890     } catch (std::out_of_range& e) {
64891       {
64892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64893       };
64894     } catch (std::exception& e) {
64895       {
64896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64897       };
64898     } catch (Dali::DaliException e) {
64899       {
64900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64901       };
64902     } catch (...) {
64903       {
64904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64905       };
64906     }
64907   }
64908
64909 }
64910
64911
64912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
64913   void * jresult ;
64914   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64915   SwigDirector_ViewImpl *darg = 0;
64916   Dali::Vector3 result;
64917
64918   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64919   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64920   if (!darg) {
64921     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64922     return 0;
64923   }
64924   {
64925     try {
64926       result = (darg)->GetNaturalSize();
64927     } catch (std::out_of_range& e) {
64928       {
64929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64930       };
64931     } catch (std::exception& e) {
64932       {
64933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64934       };
64935     } catch (Dali::DaliException e) {
64936       {
64937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64938       };
64939     } catch (...) {
64940       {
64941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64942       };
64943     }
64944   }
64945
64946   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64947   return jresult;
64948 }
64949
64950
64951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
64952   void * jresult ;
64953   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64954   SwigDirector_ViewImpl *darg = 0;
64955   Dali::Vector3 result;
64956
64957   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64958   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64959   if (!darg) {
64960     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64961     return 0;
64962   }
64963   {
64964     try {
64965       result = (darg)->GetNaturalSizeSwigPublic();
64966     } catch (std::out_of_range& e) {
64967       {
64968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64969       };
64970     } catch (std::exception& e) {
64971       {
64972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64973       };
64974     } catch (Dali::DaliException e) {
64975       {
64976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64977       };
64978     } catch (...) {
64979       {
64980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64981       };
64982     }
64983   }
64984
64985   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64986   return jresult;
64987 }
64988
64989
64990 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
64991   float jresult ;
64992   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64993   Dali::Actor *arg2 = 0 ;
64994   Dali::Dimension::Type arg3 ;
64995   SwigDirector_ViewImpl *darg = 0;
64996   float result;
64997
64998   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64999   arg2 = (Dali::Actor *)jarg2;
65000   if (!arg2) {
65001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65002     return 0;
65003   }
65004   arg3 = (Dali::Dimension::Type)jarg3;
65005   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65006   if (!darg) {
65007     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65008     return 0;
65009   }
65010   {
65011     try {
65012       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65013     } catch (std::out_of_range& e) {
65014       {
65015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65016       };
65017     } catch (std::exception& e) {
65018       {
65019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65020       };
65021     } catch (Dali::DaliException e) {
65022       {
65023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65024       };
65025     } catch (...) {
65026       {
65027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65028       };
65029     }
65030   }
65031
65032   jresult = result;
65033   return jresult;
65034 }
65035
65036
65037 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65038   float jresult ;
65039   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65040   Dali::Actor *arg2 = 0 ;
65041   Dali::Dimension::Type arg3 ;
65042   SwigDirector_ViewImpl *darg = 0;
65043   float result;
65044
65045   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65046   arg2 = (Dali::Actor *)jarg2;
65047   if (!arg2) {
65048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65049     return 0;
65050   }
65051   arg3 = (Dali::Dimension::Type)jarg3;
65052   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65053   if (!darg) {
65054     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65055     return 0;
65056   }
65057   {
65058     try {
65059       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65060     } catch (std::out_of_range& e) {
65061       {
65062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65063       };
65064     } catch (std::exception& e) {
65065       {
65066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65067       };
65068     } catch (Dali::DaliException e) {
65069       {
65070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65071       };
65072     } catch (...) {
65073       {
65074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65075       };
65076     }
65077   }
65078
65079   jresult = result;
65080   return jresult;
65081 }
65082
65083
65084 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65085   float jresult ;
65086   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65087   float arg2 ;
65088   SwigDirector_ViewImpl *darg = 0;
65089   float result;
65090
65091   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65092   arg2 = (float)jarg2;
65093   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65094   if (!darg) {
65095     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65096     return 0;
65097   }
65098   {
65099     try {
65100       result = (float)(darg)->GetHeightForWidth(arg2);
65101     } catch (std::out_of_range& e) {
65102       {
65103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65104       };
65105     } catch (std::exception& e) {
65106       {
65107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65108       };
65109     } catch (Dali::DaliException e) {
65110       {
65111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65112       };
65113     } catch (...) {
65114       {
65115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65116       };
65117     }
65118   }
65119
65120   jresult = result;
65121   return jresult;
65122 }
65123
65124
65125 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65126   float jresult ;
65127   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65128   float arg2 ;
65129   SwigDirector_ViewImpl *darg = 0;
65130   float result;
65131
65132   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65133   arg2 = (float)jarg2;
65134   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65135   if (!darg) {
65136     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65137     return 0;
65138   }
65139   {
65140     try {
65141       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65142     } catch (std::out_of_range& e) {
65143       {
65144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65145       };
65146     } catch (std::exception& e) {
65147       {
65148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65149       };
65150     } catch (Dali::DaliException e) {
65151       {
65152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65153       };
65154     } catch (...) {
65155       {
65156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65157       };
65158     }
65159   }
65160
65161   jresult = result;
65162   return jresult;
65163 }
65164
65165
65166 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65167   float jresult ;
65168   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65169   float arg2 ;
65170   SwigDirector_ViewImpl *darg = 0;
65171   float result;
65172
65173   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65174   arg2 = (float)jarg2;
65175   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65176   if (!darg) {
65177     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65178     return 0;
65179   }
65180   {
65181     try {
65182       result = (float)(darg)->GetWidthForHeight(arg2);
65183     } catch (std::out_of_range& e) {
65184       {
65185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65186       };
65187     } catch (std::exception& e) {
65188       {
65189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65190       };
65191     } catch (Dali::DaliException e) {
65192       {
65193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65194       };
65195     } catch (...) {
65196       {
65197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65198       };
65199     }
65200   }
65201
65202   jresult = result;
65203   return jresult;
65204 }
65205
65206
65207 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65208   float jresult ;
65209   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65210   float arg2 ;
65211   SwigDirector_ViewImpl *darg = 0;
65212   float result;
65213
65214   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65215   arg2 = (float)jarg2;
65216   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65217   if (!darg) {
65218     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65219     return 0;
65220   }
65221   {
65222     try {
65223       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65224     } catch (std::out_of_range& e) {
65225       {
65226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65227       };
65228     } catch (std::exception& e) {
65229       {
65230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65231       };
65232     } catch (Dali::DaliException e) {
65233       {
65234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65235       };
65236     } catch (...) {
65237       {
65238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65239       };
65240     }
65241   }
65242
65243   jresult = result;
65244   return jresult;
65245 }
65246
65247
65248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65249   unsigned int jresult ;
65250   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65251   Dali::Dimension::Type arg2 ;
65252   SwigDirector_ViewImpl *darg = 0;
65253   bool result;
65254
65255   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65256   arg2 = (Dali::Dimension::Type)jarg2;
65257   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65258   if (!darg) {
65259     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65260     return 0;
65261   }
65262   {
65263     try {
65264       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65265     } catch (std::out_of_range& e) {
65266       {
65267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65268       };
65269     } catch (std::exception& e) {
65270       {
65271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65272       };
65273     } catch (Dali::DaliException e) {
65274       {
65275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65276       };
65277     } catch (...) {
65278       {
65279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65280       };
65281     }
65282   }
65283
65284   jresult = result;
65285   return jresult;
65286 }
65287
65288
65289 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65290   unsigned int jresult ;
65291   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65292   Dali::Dimension::Type arg2 ;
65293   SwigDirector_ViewImpl *darg = 0;
65294   bool result;
65295
65296   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65297   arg2 = (Dali::Dimension::Type)jarg2;
65298   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65299   if (!darg) {
65300     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65301     return 0;
65302   }
65303   {
65304     try {
65305       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65306     } catch (std::out_of_range& e) {
65307       {
65308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65309       };
65310     } catch (std::exception& e) {
65311       {
65312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65313       };
65314     } catch (Dali::DaliException e) {
65315       {
65316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65317       };
65318     } catch (...) {
65319       {
65320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65321       };
65322     }
65323   }
65324
65325   jresult = result;
65326   return jresult;
65327 }
65328
65329
65330 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65331   unsigned int jresult ;
65332   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65333   SwigDirector_ViewImpl *darg = 0;
65334   bool result;
65335
65336   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65337   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65338   if (!darg) {
65339     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65340     return 0;
65341   }
65342   {
65343     try {
65344       result = (bool)(darg)->RelayoutDependentOnChildren();
65345     } catch (std::out_of_range& e) {
65346       {
65347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65348       };
65349     } catch (std::exception& e) {
65350       {
65351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65352       };
65353     } catch (Dali::DaliException e) {
65354       {
65355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65356       };
65357     } catch (...) {
65358       {
65359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65360       };
65361     }
65362   }
65363
65364   jresult = result;
65365   return jresult;
65366 }
65367
65368
65369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65370   unsigned int jresult ;
65371   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65372   SwigDirector_ViewImpl *darg = 0;
65373   bool result;
65374
65375   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65376   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65377   if (!darg) {
65378     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65379     return 0;
65380   }
65381   {
65382     try {
65383       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65384     } catch (std::out_of_range& e) {
65385       {
65386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65387       };
65388     } catch (std::exception& e) {
65389       {
65390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65391       };
65392     } catch (Dali::DaliException e) {
65393       {
65394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65395       };
65396     } catch (...) {
65397       {
65398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65399       };
65400     }
65401   }
65402
65403   jresult = result;
65404   return jresult;
65405 }
65406
65407
65408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65409   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65410   Dali::Dimension::Type arg2 ;
65411   SwigDirector_ViewImpl *darg = 0;
65412
65413   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65414   arg2 = (Dali::Dimension::Type)jarg2;
65415   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65416   if (!darg) {
65417     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65418     return;
65419   }
65420   {
65421     try {
65422       (darg)->OnCalculateRelayoutSize(arg2);
65423     } catch (std::out_of_range& e) {
65424       {
65425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65426       };
65427     } catch (std::exception& e) {
65428       {
65429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65430       };
65431     } catch (Dali::DaliException e) {
65432       {
65433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65434       };
65435     } catch (...) {
65436       {
65437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65438       };
65439     }
65440   }
65441
65442 }
65443
65444
65445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65446   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65447   Dali::Dimension::Type arg2 ;
65448   SwigDirector_ViewImpl *darg = 0;
65449
65450   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65451   arg2 = (Dali::Dimension::Type)jarg2;
65452   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65453   if (!darg) {
65454     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65455     return;
65456   }
65457   {
65458     try {
65459       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65460     } catch (std::out_of_range& e) {
65461       {
65462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65463       };
65464     } catch (std::exception& e) {
65465       {
65466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65467       };
65468     } catch (Dali::DaliException e) {
65469       {
65470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65471       };
65472     } catch (...) {
65473       {
65474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65475       };
65476     }
65477   }
65478
65479 }
65480
65481
65482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65483   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65484   float arg2 ;
65485   Dali::Dimension::Type arg3 ;
65486   SwigDirector_ViewImpl *darg = 0;
65487
65488   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65489   arg2 = (float)jarg2;
65490   arg3 = (Dali::Dimension::Type)jarg3;
65491   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65492   if (!darg) {
65493     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65494     return;
65495   }
65496   {
65497     try {
65498       (darg)->OnLayoutNegotiated(arg2,arg3);
65499     } catch (std::out_of_range& e) {
65500       {
65501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65502       };
65503     } catch (std::exception& e) {
65504       {
65505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65506       };
65507     } catch (Dali::DaliException e) {
65508       {
65509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65510       };
65511     } catch (...) {
65512       {
65513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65514       };
65515     }
65516   }
65517
65518 }
65519
65520
65521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65522   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65523   float arg2 ;
65524   Dali::Dimension::Type arg3 ;
65525   SwigDirector_ViewImpl *darg = 0;
65526
65527   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65528   arg2 = (float)jarg2;
65529   arg3 = (Dali::Dimension::Type)jarg3;
65530   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65531   if (!darg) {
65532     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65533     return;
65534   }
65535   {
65536     try {
65537       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65538     } catch (std::out_of_range& e) {
65539       {
65540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65541       };
65542     } catch (std::exception& e) {
65543       {
65544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65545       };
65546     } catch (Dali::DaliException e) {
65547       {
65548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65549       };
65550     } catch (...) {
65551       {
65552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65553       };
65554     }
65555   }
65556
65557 }
65558
65559
65560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65561   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65562
65563   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65564   {
65565     try {
65566       (arg1)->OnInitialize();
65567     } catch (std::out_of_range& e) {
65568       {
65569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65570       };
65571     } catch (std::exception& e) {
65572       {
65573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65574       };
65575     } catch (Dali::DaliException e) {
65576       {
65577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65578       };
65579     } catch (...) {
65580       {
65581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65582       };
65583     }
65584   }
65585
65586 }
65587
65588
65589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65590   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65591
65592   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65593   {
65594     try {
65595       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65596     } catch (std::out_of_range& e) {
65597       {
65598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65599       };
65600     } catch (std::exception& e) {
65601       {
65602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65603       };
65604     } catch (Dali::DaliException e) {
65605       {
65606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65607       };
65608     } catch (...) {
65609       {
65610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65611       };
65612     }
65613   }
65614
65615 }
65616
65617
65618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
65619   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65620   Dali::Actor *arg2 = 0 ;
65621
65622   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65623   arg2 = (Dali::Actor *)jarg2;
65624   if (!arg2) {
65625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65626     return ;
65627   }
65628   {
65629     try {
65630       (arg1)->OnControlChildAdd(*arg2);
65631     } catch (std::out_of_range& e) {
65632       {
65633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65634       };
65635     } catch (std::exception& e) {
65636       {
65637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65638       };
65639     } catch (Dali::DaliException e) {
65640       {
65641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65642       };
65643     } catch (...) {
65644       {
65645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65646       };
65647     }
65648   }
65649
65650 }
65651
65652
65653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65654   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65655   Dali::Actor *arg2 = 0 ;
65656
65657   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65658   arg2 = (Dali::Actor *)jarg2;
65659   if (!arg2) {
65660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65661     return ;
65662   }
65663   {
65664     try {
65665       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
65666     } catch (std::out_of_range& e) {
65667       {
65668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65669       };
65670     } catch (std::exception& e) {
65671       {
65672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65673       };
65674     } catch (Dali::DaliException e) {
65675       {
65676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65677       };
65678     } catch (...) {
65679       {
65680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65681       };
65682     }
65683   }
65684
65685 }
65686
65687
65688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
65689   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65690   Dali::Actor *arg2 = 0 ;
65691
65692   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65693   arg2 = (Dali::Actor *)jarg2;
65694   if (!arg2) {
65695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65696     return ;
65697   }
65698   {
65699     try {
65700       (arg1)->OnControlChildRemove(*arg2);
65701     } catch (std::out_of_range& e) {
65702       {
65703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65704       };
65705     } catch (std::exception& e) {
65706       {
65707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65708       };
65709     } catch (Dali::DaliException e) {
65710       {
65711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65712       };
65713     } catch (...) {
65714       {
65715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65716       };
65717     }
65718   }
65719
65720 }
65721
65722
65723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65724   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65725   Dali::Actor *arg2 = 0 ;
65726
65727   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65728   arg2 = (Dali::Actor *)jarg2;
65729   if (!arg2) {
65730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65731     return ;
65732   }
65733   {
65734     try {
65735       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
65736     } catch (std::out_of_range& e) {
65737       {
65738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65739       };
65740     } catch (std::exception& e) {
65741       {
65742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65743       };
65744     } catch (Dali::DaliException e) {
65745       {
65746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65747       };
65748     } catch (...) {
65749       {
65750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65751       };
65752     }
65753   }
65754
65755 }
65756
65757
65758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
65759   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65760   Dali::Toolkit::StyleManager arg2 ;
65761   Dali::StyleChange::Type arg3 ;
65762   Dali::Toolkit::StyleManager *argp2 ;
65763
65764   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65765   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65766   if (!argp2) {
65767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65768     return ;
65769   }
65770   arg2 = *argp2;
65771   arg3 = (Dali::StyleChange::Type)jarg3;
65772   {
65773     try {
65774       (arg1)->OnStyleChange(arg2,arg3);
65775     } catch (std::out_of_range& e) {
65776       {
65777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65778       };
65779     } catch (std::exception& e) {
65780       {
65781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65782       };
65783     } catch (Dali::DaliException e) {
65784       {
65785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65786       };
65787     } catch (...) {
65788       {
65789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65790       };
65791     }
65792   }
65793
65794 }
65795
65796
65797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65798   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65799   Dali::Toolkit::StyleManager arg2 ;
65800   Dali::StyleChange::Type arg3 ;
65801   Dali::Toolkit::StyleManager *argp2 ;
65802
65803   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65804   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65805   if (!argp2) {
65806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65807     return ;
65808   }
65809   arg2 = *argp2;
65810   arg3 = (Dali::StyleChange::Type)jarg3;
65811   {
65812     try {
65813       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
65814     } catch (std::out_of_range& e) {
65815       {
65816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65817       };
65818     } catch (std::exception& e) {
65819       {
65820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65821       };
65822     } catch (Dali::DaliException e) {
65823       {
65824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65825       };
65826     } catch (...) {
65827       {
65828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65829       };
65830     }
65831   }
65832
65833 }
65834
65835
65836 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
65837   unsigned int jresult ;
65838   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65839   bool result;
65840
65841   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65842   {
65843     try {
65844       result = (bool)(arg1)->OnAccessibilityActivated();
65845     } catch (std::out_of_range& e) {
65846       {
65847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65848       };
65849     } catch (std::exception& e) {
65850       {
65851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65852       };
65853     } catch (Dali::DaliException e) {
65854       {
65855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65856       };
65857     } catch (...) {
65858       {
65859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65860       };
65861     }
65862   }
65863
65864   jresult = result;
65865   return jresult;
65866 }
65867
65868
65869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
65870   unsigned int jresult ;
65871   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65872   bool result;
65873
65874   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65875   {
65876     try {
65877       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
65878     } catch (std::out_of_range& e) {
65879       {
65880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65881       };
65882     } catch (std::exception& e) {
65883       {
65884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65885       };
65886     } catch (Dali::DaliException e) {
65887       {
65888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65889       };
65890     } catch (...) {
65891       {
65892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65893       };
65894     }
65895   }
65896
65897   jresult = result;
65898   return jresult;
65899 }
65900
65901
65902 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
65903   unsigned int jresult ;
65904   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65905   Dali::PanGesture arg2 ;
65906   Dali::PanGesture *argp2 ;
65907   bool result;
65908
65909   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65910   argp2 = (Dali::PanGesture *)jarg2;
65911   if (!argp2) {
65912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65913     return 0;
65914   }
65915   arg2 = *argp2;
65916   {
65917     try {
65918       result = (bool)(arg1)->OnAccessibilityPan(arg2);
65919     } catch (std::out_of_range& e) {
65920       {
65921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65922       };
65923     } catch (std::exception& e) {
65924       {
65925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65926       };
65927     } catch (Dali::DaliException e) {
65928       {
65929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65930       };
65931     } catch (...) {
65932       {
65933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65934       };
65935     }
65936   }
65937
65938   jresult = result;
65939   return jresult;
65940 }
65941
65942
65943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65944   unsigned int jresult ;
65945   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65946   Dali::PanGesture arg2 ;
65947   Dali::PanGesture *argp2 ;
65948   bool result;
65949
65950   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65951   argp2 = (Dali::PanGesture *)jarg2;
65952   if (!argp2) {
65953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65954     return 0;
65955   }
65956   arg2 = *argp2;
65957   {
65958     try {
65959       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
65960     } catch (std::out_of_range& e) {
65961       {
65962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65963       };
65964     } catch (std::exception& e) {
65965       {
65966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65967       };
65968     } catch (Dali::DaliException e) {
65969       {
65970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65971       };
65972     } catch (...) {
65973       {
65974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65975       };
65976     }
65977   }
65978
65979   jresult = result;
65980   return jresult;
65981 }
65982
65983
65984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
65985   unsigned int jresult ;
65986   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65987   Dali::TouchEvent *arg2 = 0 ;
65988   bool result;
65989
65990   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65991   arg2 = (Dali::TouchEvent *)jarg2;
65992   if (!arg2) {
65993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65994     return 0;
65995   }
65996   {
65997     try {
65998       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
65999     } catch (std::out_of_range& e) {
66000       {
66001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66002       };
66003     } catch (std::exception& e) {
66004       {
66005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66006       };
66007     } catch (Dali::DaliException e) {
66008       {
66009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66010       };
66011     } catch (...) {
66012       {
66013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66014       };
66015     }
66016   }
66017
66018   jresult = result;
66019   return jresult;
66020 }
66021
66022
66023 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66024   unsigned int jresult ;
66025   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66026   Dali::TouchEvent *arg2 = 0 ;
66027   bool result;
66028
66029   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66030   arg2 = (Dali::TouchEvent *)jarg2;
66031   if (!arg2) {
66032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66033     return 0;
66034   }
66035   {
66036     try {
66037       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66038     } catch (std::out_of_range& e) {
66039       {
66040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66041       };
66042     } catch (std::exception& e) {
66043       {
66044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66045       };
66046     } catch (Dali::DaliException e) {
66047       {
66048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66049       };
66050     } catch (...) {
66051       {
66052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66053       };
66054     }
66055   }
66056
66057   jresult = result;
66058   return jresult;
66059 }
66060
66061
66062 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66063   unsigned int jresult ;
66064   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66065   bool arg2 ;
66066   bool result;
66067
66068   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66069   arg2 = jarg2 ? true : false;
66070   {
66071     try {
66072       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66073     } catch (std::out_of_range& e) {
66074       {
66075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66076       };
66077     } catch (std::exception& e) {
66078       {
66079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66080       };
66081     } catch (Dali::DaliException e) {
66082       {
66083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66084       };
66085     } catch (...) {
66086       {
66087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66088       };
66089     }
66090   }
66091
66092   jresult = result;
66093   return jresult;
66094 }
66095
66096
66097 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66098   unsigned int jresult ;
66099   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66100   bool arg2 ;
66101   bool result;
66102
66103   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66104   arg2 = jarg2 ? true : false;
66105   {
66106     try {
66107       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66108     } catch (std::out_of_range& e) {
66109       {
66110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66111       };
66112     } catch (std::exception& e) {
66113       {
66114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66115       };
66116     } catch (Dali::DaliException e) {
66117       {
66118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66119       };
66120     } catch (...) {
66121       {
66122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66123       };
66124     }
66125   }
66126
66127   jresult = result;
66128   return jresult;
66129 }
66130
66131
66132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66133   unsigned int jresult ;
66134   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66135   bool result;
66136
66137   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66138   {
66139     try {
66140       result = (bool)(arg1)->OnAccessibilityZoom();
66141     } catch (std::out_of_range& e) {
66142       {
66143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66144       };
66145     } catch (std::exception& e) {
66146       {
66147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66148       };
66149     } catch (Dali::DaliException e) {
66150       {
66151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66152       };
66153     } catch (...) {
66154       {
66155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66156       };
66157     }
66158   }
66159
66160   jresult = result;
66161   return jresult;
66162 }
66163
66164
66165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66166   unsigned int jresult ;
66167   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66168   bool result;
66169
66170   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66171   {
66172     try {
66173       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66174     } catch (std::out_of_range& e) {
66175       {
66176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66177       };
66178     } catch (std::exception& e) {
66179       {
66180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66181       };
66182     } catch (Dali::DaliException e) {
66183       {
66184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66185       };
66186     } catch (...) {
66187       {
66188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66189       };
66190     }
66191   }
66192
66193   jresult = result;
66194   return jresult;
66195 }
66196
66197
66198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66199   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66200
66201   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66202   {
66203     try {
66204       (arg1)->OnKeyInputFocusGained();
66205     } catch (std::out_of_range& e) {
66206       {
66207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66208       };
66209     } catch (std::exception& e) {
66210       {
66211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66212       };
66213     } catch (Dali::DaliException e) {
66214       {
66215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66216       };
66217     } catch (...) {
66218       {
66219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66220       };
66221     }
66222   }
66223
66224 }
66225
66226
66227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66228   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66229
66230   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66231   {
66232     try {
66233       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66234     } catch (std::out_of_range& e) {
66235       {
66236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66237       };
66238     } catch (std::exception& e) {
66239       {
66240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66241       };
66242     } catch (Dali::DaliException e) {
66243       {
66244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66245       };
66246     } catch (...) {
66247       {
66248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66249       };
66250     }
66251   }
66252
66253 }
66254
66255
66256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66257   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66258
66259   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66260   {
66261     try {
66262       (arg1)->OnKeyInputFocusLost();
66263     } catch (std::out_of_range& e) {
66264       {
66265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66266       };
66267     } catch (std::exception& e) {
66268       {
66269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66270       };
66271     } catch (Dali::DaliException e) {
66272       {
66273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66274       };
66275     } catch (...) {
66276       {
66277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66278       };
66279     }
66280   }
66281
66282 }
66283
66284
66285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66286   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66287
66288   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66289   {
66290     try {
66291       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66292     } catch (std::out_of_range& e) {
66293       {
66294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66295       };
66296     } catch (std::exception& e) {
66297       {
66298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66299       };
66300     } catch (Dali::DaliException e) {
66301       {
66302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66303       };
66304     } catch (...) {
66305       {
66306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66307       };
66308     }
66309   }
66310
66311 }
66312
66313
66314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66315   void * jresult ;
66316   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66317   Dali::Actor arg2 ;
66318   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66319   bool arg4 ;
66320   Dali::Actor *argp2 ;
66321   Dali::Actor result;
66322
66323   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66324   argp2 = (Dali::Actor *)jarg2;
66325   if (!argp2) {
66326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66327     return 0;
66328   }
66329   arg2 = *argp2;
66330   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66331   arg4 = jarg4 ? true : false;
66332   {
66333     try {
66334       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66335     } catch (std::out_of_range& e) {
66336       {
66337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66338       };
66339     } catch (std::exception& e) {
66340       {
66341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66342       };
66343     } catch (Dali::DaliException e) {
66344       {
66345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66346       };
66347     } catch (...) {
66348       {
66349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66350       };
66351     }
66352   }
66353
66354   jresult = new Dali::Actor((const Dali::Actor &)result);
66355   return jresult;
66356 }
66357
66358
66359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66360   void * jresult ;
66361   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66362   Dali::Actor arg2 ;
66363   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66364   bool arg4 ;
66365   Dali::Actor *argp2 ;
66366   Dali::Actor result;
66367
66368   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66369   argp2 = (Dali::Actor *)jarg2;
66370   if (!argp2) {
66371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66372     return 0;
66373   }
66374   arg2 = *argp2;
66375   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66376   arg4 = jarg4 ? true : false;
66377   {
66378     try {
66379       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66380     } catch (std::out_of_range& e) {
66381       {
66382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66383       };
66384     } catch (std::exception& e) {
66385       {
66386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66387       };
66388     } catch (Dali::DaliException e) {
66389       {
66390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66391       };
66392     } catch (...) {
66393       {
66394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66395       };
66396     }
66397   }
66398
66399   jresult = new Dali::Actor((const Dali::Actor &)result);
66400   return jresult;
66401 }
66402
66403
66404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66405   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66406   Dali::Actor arg2 ;
66407   Dali::Actor *argp2 ;
66408
66409   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66410   argp2 = (Dali::Actor *)jarg2;
66411   if (!argp2) {
66412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66413     return ;
66414   }
66415   arg2 = *argp2;
66416   {
66417     try {
66418       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66419     } catch (std::out_of_range& e) {
66420       {
66421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66422       };
66423     } catch (std::exception& e) {
66424       {
66425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66426       };
66427     } catch (Dali::DaliException e) {
66428       {
66429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66430       };
66431     } catch (...) {
66432       {
66433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66434       };
66435     }
66436   }
66437
66438 }
66439
66440
66441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66442   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66443   Dali::Actor arg2 ;
66444   Dali::Actor *argp2 ;
66445
66446   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66447   argp2 = (Dali::Actor *)jarg2;
66448   if (!argp2) {
66449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66450     return ;
66451   }
66452   arg2 = *argp2;
66453   {
66454     try {
66455       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66456     } catch (std::out_of_range& e) {
66457       {
66458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66459       };
66460     } catch (std::exception& e) {
66461       {
66462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66463       };
66464     } catch (Dali::DaliException e) {
66465       {
66466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66467       };
66468     } catch (...) {
66469       {
66470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66471       };
66472     }
66473   }
66474
66475 }
66476
66477
66478 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66479   unsigned int jresult ;
66480   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66481   bool result;
66482
66483   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66484   {
66485     try {
66486       result = (bool)(arg1)->OnKeyboardEnter();
66487     } catch (std::out_of_range& e) {
66488       {
66489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66490       };
66491     } catch (std::exception& e) {
66492       {
66493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66494       };
66495     } catch (Dali::DaliException e) {
66496       {
66497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66498       };
66499     } catch (...) {
66500       {
66501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66502       };
66503     }
66504   }
66505
66506   jresult = result;
66507   return jresult;
66508 }
66509
66510
66511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66512   unsigned int jresult ;
66513   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66514   bool result;
66515
66516   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66517   {
66518     try {
66519       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66520     } catch (std::out_of_range& e) {
66521       {
66522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66523       };
66524     } catch (std::exception& e) {
66525       {
66526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66527       };
66528     } catch (Dali::DaliException e) {
66529       {
66530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66531       };
66532     } catch (...) {
66533       {
66534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66535       };
66536     }
66537   }
66538
66539   jresult = result;
66540   return jresult;
66541 }
66542
66543
66544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66545   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66546   Dali::PinchGesture *arg2 = 0 ;
66547
66548   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66549   arg2 = (Dali::PinchGesture *)jarg2;
66550   if (!arg2) {
66551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66552     return ;
66553   }
66554   {
66555     try {
66556       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66557     } catch (std::out_of_range& e) {
66558       {
66559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66560       };
66561     } catch (std::exception& e) {
66562       {
66563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66564       };
66565     } catch (Dali::DaliException e) {
66566       {
66567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66568       };
66569     } catch (...) {
66570       {
66571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66572       };
66573     }
66574   }
66575
66576 }
66577
66578
66579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66580   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66581   Dali::PinchGesture *arg2 = 0 ;
66582
66583   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66584   arg2 = (Dali::PinchGesture *)jarg2;
66585   if (!arg2) {
66586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66587     return ;
66588   }
66589   {
66590     try {
66591       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66592     } catch (std::out_of_range& e) {
66593       {
66594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66595       };
66596     } catch (std::exception& e) {
66597       {
66598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66599       };
66600     } catch (Dali::DaliException e) {
66601       {
66602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66603       };
66604     } catch (...) {
66605       {
66606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66607       };
66608     }
66609   }
66610
66611 }
66612
66613
66614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
66615   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66616   Dali::PanGesture *arg2 = 0 ;
66617
66618   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66619   arg2 = (Dali::PanGesture *)jarg2;
66620   if (!arg2) {
66621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66622     return ;
66623   }
66624   {
66625     try {
66626       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
66627     } catch (std::out_of_range& e) {
66628       {
66629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66630       };
66631     } catch (std::exception& e) {
66632       {
66633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66634       };
66635     } catch (Dali::DaliException e) {
66636       {
66637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66638       };
66639     } catch (...) {
66640       {
66641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66642       };
66643     }
66644   }
66645
66646 }
66647
66648
66649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66650   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66651   Dali::PanGesture *arg2 = 0 ;
66652
66653   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66654   arg2 = (Dali::PanGesture *)jarg2;
66655   if (!arg2) {
66656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66657     return ;
66658   }
66659   {
66660     try {
66661       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
66662     } catch (std::out_of_range& e) {
66663       {
66664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66665       };
66666     } catch (std::exception& e) {
66667       {
66668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66669       };
66670     } catch (Dali::DaliException e) {
66671       {
66672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66673       };
66674     } catch (...) {
66675       {
66676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66677       };
66678     }
66679   }
66680
66681 }
66682
66683
66684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
66685   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66686   Dali::TapGesture *arg2 = 0 ;
66687
66688   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66689   arg2 = (Dali::TapGesture *)jarg2;
66690   if (!arg2) {
66691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66692     return ;
66693   }
66694   {
66695     try {
66696       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
66697     } catch (std::out_of_range& e) {
66698       {
66699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66700       };
66701     } catch (std::exception& e) {
66702       {
66703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66704       };
66705     } catch (Dali::DaliException e) {
66706       {
66707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66708       };
66709     } catch (...) {
66710       {
66711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66712       };
66713     }
66714   }
66715
66716 }
66717
66718
66719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66720   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66721   Dali::TapGesture *arg2 = 0 ;
66722
66723   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66724   arg2 = (Dali::TapGesture *)jarg2;
66725   if (!arg2) {
66726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66727     return ;
66728   }
66729   {
66730     try {
66731       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
66732     } catch (std::out_of_range& e) {
66733       {
66734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66735       };
66736     } catch (std::exception& e) {
66737       {
66738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66739       };
66740     } catch (Dali::DaliException e) {
66741       {
66742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66743       };
66744     } catch (...) {
66745       {
66746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66747       };
66748     }
66749   }
66750
66751 }
66752
66753
66754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
66755   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66756   Dali::LongPressGesture *arg2 = 0 ;
66757
66758   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66759   arg2 = (Dali::LongPressGesture *)jarg2;
66760   if (!arg2) {
66761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66762     return ;
66763   }
66764   {
66765     try {
66766       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
66767     } catch (std::out_of_range& e) {
66768       {
66769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66770       };
66771     } catch (std::exception& e) {
66772       {
66773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66774       };
66775     } catch (Dali::DaliException e) {
66776       {
66777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66778       };
66779     } catch (...) {
66780       {
66781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66782       };
66783     }
66784   }
66785
66786 }
66787
66788
66789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66790   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66791   Dali::LongPressGesture *arg2 = 0 ;
66792
66793   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66794   arg2 = (Dali::LongPressGesture *)jarg2;
66795   if (!arg2) {
66796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66797     return ;
66798   }
66799   {
66800     try {
66801       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
66802     } catch (std::out_of_range& e) {
66803       {
66804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66805       };
66806     } catch (std::exception& e) {
66807       {
66808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66809       };
66810     } catch (Dali::DaliException e) {
66811       {
66812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66813       };
66814     } catch (...) {
66815       {
66816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66817       };
66818     }
66819   }
66820
66821 }
66822
66823
66824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
66825   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66826   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66827   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66828
66829   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66830   arg2 = (Dali::SlotObserver *)jarg2;
66831   arg3 = (Dali::CallbackBase *)jarg3;
66832   {
66833     try {
66834       (arg1)->SignalConnected(arg2,arg3);
66835     } catch (std::out_of_range& e) {
66836       {
66837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66838       };
66839     } catch (std::exception& e) {
66840       {
66841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66842       };
66843     } catch (Dali::DaliException e) {
66844       {
66845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66846       };
66847     } catch (...) {
66848       {
66849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66850       };
66851     }
66852   }
66853
66854 }
66855
66856
66857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66858   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66859   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66860   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66861
66862   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66863   arg2 = (Dali::SlotObserver *)jarg2;
66864   arg3 = (Dali::CallbackBase *)jarg3;
66865   {
66866     try {
66867       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
66868     } catch (std::out_of_range& e) {
66869       {
66870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66871       };
66872     } catch (std::exception& e) {
66873       {
66874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66875       };
66876     } catch (Dali::DaliException e) {
66877       {
66878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66879       };
66880     } catch (...) {
66881       {
66882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66883       };
66884     }
66885   }
66886
66887 }
66888
66889
66890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
66891   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66892   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66893   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66894
66895   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66896   arg2 = (Dali::SlotObserver *)jarg2;
66897   arg3 = (Dali::CallbackBase *)jarg3;
66898   {
66899     try {
66900       (arg1)->SignalDisconnected(arg2,arg3);
66901     } catch (std::out_of_range& e) {
66902       {
66903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66904       };
66905     } catch (std::exception& e) {
66906       {
66907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66908       };
66909     } catch (Dali::DaliException e) {
66910       {
66911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66912       };
66913     } catch (...) {
66914       {
66915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66916       };
66917     }
66918   }
66919
66920 }
66921
66922
66923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66924   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66925   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66926   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66927
66928   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66929   arg2 = (Dali::SlotObserver *)jarg2;
66930   arg3 = (Dali::CallbackBase *)jarg3;
66931   {
66932     try {
66933       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
66934     } catch (std::out_of_range& e) {
66935       {
66936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66937       };
66938     } catch (std::exception& e) {
66939       {
66940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66941       };
66942     } catch (Dali::DaliException e) {
66943       {
66944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66945       };
66946     } catch (...) {
66947       {
66948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66949       };
66950     }
66951   }
66952
66953 }
66954
66955
66956 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) {
66957   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
66958   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
66959   if (director) {
66960     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);
66961   }
66962 }
66963
66964
66965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
66966   void * jresult ;
66967   Dali::Toolkit::Control *arg1 = 0 ;
66968   Dali::Toolkit::Internal::Control *result = 0 ;
66969
66970   arg1 = (Dali::Toolkit::Control *)jarg1;
66971   if (!arg1) {
66972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
66973     return 0;
66974   }
66975   {
66976     try {
66977       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
66978     } catch (std::out_of_range& e) {
66979       {
66980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66981       };
66982     } catch (std::exception& e) {
66983       {
66984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66985       };
66986     } catch (Dali::DaliException e) {
66987       {
66988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66989       };
66990     } catch (...) {
66991       {
66992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66993       };
66994     }
66995   }
66996
66997   jresult = (void *)result;
66998   return jresult;
66999 }
67000
67001
67002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
67003   int jresult ;
67004   int result;
67005
67006   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
67007   jresult = (int)result;
67008   return jresult;
67009 }
67010
67011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67012   int jresult ;
67013   int result;
67014
67015   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67016   jresult = (int)result;
67017   return jresult;
67018 }
67019
67020
67021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67022   int jresult ;
67023   int result;
67024
67025   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67026   jresult = (int)result;
67027   return jresult;
67028 }
67029
67030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67031   int jresult ;
67032   int result;
67033
67034   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67035   jresult = (int)result;
67036   return jresult;
67037 }
67038
67039
67040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67041   int jresult ;
67042   int result;
67043
67044   result = (int)Dali::Toolkit::Control::Property::PADDING;
67045   jresult = (int)result;
67046   return jresult;
67047 }
67048
67049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
67050   int jresult ;
67051   int result;
67052
67053   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
67054   jresult = (int)result;
67055   return jresult;
67056 }
67057
67058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67059   void * jresult ;
67060   Dali::Toolkit::Control::Property *result = 0 ;
67061
67062   {
67063     try {
67064       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67065     } catch (std::out_of_range& e) {
67066       {
67067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67068       };
67069     } catch (std::exception& e) {
67070       {
67071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67072       };
67073     } catch (Dali::DaliException e) {
67074       {
67075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67076       };
67077     } catch (...) {
67078       {
67079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67080       };
67081     }
67082   }
67083
67084   jresult = (void *)result;
67085   return jresult;
67086 }
67087
67088
67089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67090   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67091
67092   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67093   {
67094     try {
67095       delete arg1;
67096     } catch (std::out_of_range& e) {
67097       {
67098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67099       };
67100     } catch (std::exception& e) {
67101       {
67102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67103       };
67104     } catch (Dali::DaliException e) {
67105       {
67106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67107       };
67108     } catch (...) {
67109       {
67110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67111       };
67112     }
67113   }
67114
67115 }
67116
67117
67118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67119   void * jresult ;
67120   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67121
67122   {
67123     try {
67124       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67125     } catch (std::out_of_range& e) {
67126       {
67127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67128       };
67129     } catch (std::exception& e) {
67130       {
67131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67132       };
67133     } catch (Dali::DaliException e) {
67134       {
67135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67136       };
67137     } catch (...) {
67138       {
67139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67140       };
67141     }
67142   }
67143
67144   jresult = (void *)result;
67145   return jresult;
67146 }
67147
67148
67149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67150   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67151
67152   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67153   {
67154     try {
67155       delete arg1;
67156     } catch (std::out_of_range& e) {
67157       {
67158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67159       };
67160     } catch (std::exception& e) {
67161       {
67162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67163       };
67164     } catch (Dali::DaliException e) {
67165       {
67166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67167       };
67168     } catch (...) {
67169       {
67170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67171       };
67172     }
67173   }
67174
67175 }
67176
67177
67178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67179   void * jresult ;
67180   Dali::Toolkit::Control result;
67181
67182   {
67183     try {
67184       result = Dali::Toolkit::Control::New();
67185     } catch (std::out_of_range& e) {
67186       {
67187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67188       };
67189     } catch (std::exception& e) {
67190       {
67191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67192       };
67193     } catch (Dali::DaliException e) {
67194       {
67195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67196       };
67197     } catch (...) {
67198       {
67199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67200       };
67201     }
67202   }
67203
67204   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67205   return jresult;
67206 }
67207
67208
67209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67210   void * jresult ;
67211   Dali::Toolkit::Control *result = 0 ;
67212
67213   {
67214     try {
67215       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67216     } catch (std::out_of_range& e) {
67217       {
67218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67219       };
67220     } catch (std::exception& e) {
67221       {
67222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67223       };
67224     } catch (Dali::DaliException e) {
67225       {
67226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67227       };
67228     } catch (...) {
67229       {
67230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67231       };
67232     }
67233   }
67234
67235   jresult = (void *)result;
67236   return jresult;
67237 }
67238
67239
67240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67241   void * jresult ;
67242   Dali::Toolkit::Control *arg1 = 0 ;
67243   Dali::Toolkit::Control *result = 0 ;
67244
67245   arg1 = (Dali::Toolkit::Control *)jarg1;
67246   if (!arg1) {
67247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67248     return 0;
67249   }
67250   {
67251     try {
67252       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67253     } catch (std::out_of_range& e) {
67254       {
67255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67256       };
67257     } catch (std::exception& e) {
67258       {
67259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67260       };
67261     } catch (Dali::DaliException e) {
67262       {
67263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67264       };
67265     } catch (...) {
67266       {
67267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67268       };
67269     }
67270   }
67271
67272   jresult = (void *)result;
67273   return jresult;
67274 }
67275
67276
67277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67278   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67279
67280   arg1 = (Dali::Toolkit::Control *)jarg1;
67281   {
67282     try {
67283       delete arg1;
67284     } catch (std::out_of_range& e) {
67285       {
67286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67287       };
67288     } catch (std::exception& e) {
67289       {
67290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67291       };
67292     } catch (Dali::DaliException e) {
67293       {
67294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67295       };
67296     } catch (...) {
67297       {
67298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67299       };
67300     }
67301   }
67302
67303 }
67304
67305
67306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67307   void * jresult ;
67308   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67309   Dali::Toolkit::Control *arg2 = 0 ;
67310   Dali::Toolkit::Control *result = 0 ;
67311
67312   arg1 = (Dali::Toolkit::Control *)jarg1;
67313   arg2 = (Dali::Toolkit::Control *)jarg2;
67314   if (!arg2) {
67315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67316     return 0;
67317   }
67318   {
67319     try {
67320       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67321     } catch (std::out_of_range& e) {
67322       {
67323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67324       };
67325     } catch (std::exception& e) {
67326       {
67327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67328       };
67329     } catch (Dali::DaliException e) {
67330       {
67331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67332       };
67333     } catch (...) {
67334       {
67335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67336       };
67337     }
67338   }
67339
67340   jresult = (void *)result;
67341   return jresult;
67342 }
67343
67344
67345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67346   void * jresult ;
67347   Dali::BaseHandle arg1 ;
67348   Dali::BaseHandle *argp1 ;
67349   Dali::Toolkit::Control result;
67350
67351   argp1 = (Dali::BaseHandle *)jarg1;
67352   if (!argp1) {
67353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67354     return 0;
67355   }
67356   arg1 = *argp1;
67357   {
67358     try {
67359       result = Dali::Toolkit::Control::DownCast(arg1);
67360     } catch (std::out_of_range& e) {
67361       {
67362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67363       };
67364     } catch (std::exception& e) {
67365       {
67366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67367       };
67368     } catch (Dali::DaliException e) {
67369       {
67370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67371       };
67372     } catch (...) {
67373       {
67374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67375       };
67376     }
67377   }
67378
67379   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67380   return jresult;
67381 }
67382
67383
67384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67385   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67386
67387   arg1 = (Dali::Toolkit::Control *)jarg1;
67388   {
67389     try {
67390       (arg1)->SetKeyInputFocus();
67391     } catch (std::out_of_range& e) {
67392       {
67393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67394       };
67395     } catch (std::exception& e) {
67396       {
67397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67398       };
67399     } catch (Dali::DaliException e) {
67400       {
67401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67402       };
67403     } catch (...) {
67404       {
67405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67406       };
67407     }
67408   }
67409
67410 }
67411
67412
67413 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67414   unsigned int jresult ;
67415   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67416   bool result;
67417
67418   arg1 = (Dali::Toolkit::Control *)jarg1;
67419   {
67420     try {
67421       result = (bool)(arg1)->HasKeyInputFocus();
67422     } catch (std::out_of_range& e) {
67423       {
67424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67425       };
67426     } catch (std::exception& e) {
67427       {
67428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67429       };
67430     } catch (Dali::DaliException e) {
67431       {
67432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67433       };
67434     } catch (...) {
67435       {
67436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67437       };
67438     }
67439   }
67440
67441   jresult = result;
67442   return jresult;
67443 }
67444
67445
67446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67447   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67448
67449   arg1 = (Dali::Toolkit::Control *)jarg1;
67450   {
67451     try {
67452       (arg1)->ClearKeyInputFocus();
67453     } catch (std::out_of_range& e) {
67454       {
67455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67456       };
67457     } catch (std::exception& e) {
67458       {
67459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67460       };
67461     } catch (Dali::DaliException e) {
67462       {
67463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67464       };
67465     } catch (...) {
67466       {
67467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67468       };
67469     }
67470   }
67471
67472 }
67473
67474
67475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67476   void * jresult ;
67477   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67478   Dali::PinchGestureDetector result;
67479
67480   arg1 = (Dali::Toolkit::Control *)jarg1;
67481   {
67482     try {
67483       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67484     } catch (std::out_of_range& e) {
67485       {
67486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67487       };
67488     } catch (std::exception& e) {
67489       {
67490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67491       };
67492     } catch (Dali::DaliException e) {
67493       {
67494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67495       };
67496     } catch (...) {
67497       {
67498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67499       };
67500     }
67501   }
67502
67503   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67504   return jresult;
67505 }
67506
67507
67508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67509   void * jresult ;
67510   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67511   Dali::PanGestureDetector result;
67512
67513   arg1 = (Dali::Toolkit::Control *)jarg1;
67514   {
67515     try {
67516       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67517     } catch (std::out_of_range& e) {
67518       {
67519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67520       };
67521     } catch (std::exception& e) {
67522       {
67523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67524       };
67525     } catch (Dali::DaliException e) {
67526       {
67527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67528       };
67529     } catch (...) {
67530       {
67531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67532       };
67533     }
67534   }
67535
67536   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67537   return jresult;
67538 }
67539
67540
67541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67542   void * jresult ;
67543   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67544   Dali::TapGestureDetector result;
67545
67546   arg1 = (Dali::Toolkit::Control *)jarg1;
67547   {
67548     try {
67549       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67550     } catch (std::out_of_range& e) {
67551       {
67552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67553       };
67554     } catch (std::exception& e) {
67555       {
67556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67557       };
67558     } catch (Dali::DaliException e) {
67559       {
67560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67561       };
67562     } catch (...) {
67563       {
67564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67565       };
67566     }
67567   }
67568
67569   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67570   return jresult;
67571 }
67572
67573
67574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67575   void * jresult ;
67576   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67577   Dali::LongPressGestureDetector result;
67578
67579   arg1 = (Dali::Toolkit::Control *)jarg1;
67580   {
67581     try {
67582       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67583     } catch (std::out_of_range& e) {
67584       {
67585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67586       };
67587     } catch (std::exception& e) {
67588       {
67589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67590       };
67591     } catch (Dali::DaliException e) {
67592       {
67593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67594       };
67595     } catch (...) {
67596       {
67597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67598       };
67599     }
67600   }
67601
67602   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
67603   return jresult;
67604 }
67605
67606
67607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
67608   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67609   std::string *arg2 = 0 ;
67610
67611   arg1 = (Dali::Toolkit::Control *)jarg1;
67612   if (!jarg2) {
67613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67614     return ;
67615   }
67616   std::string arg2_str(jarg2);
67617   arg2 = &arg2_str;
67618   {
67619     try {
67620       (arg1)->SetStyleName((std::string const &)*arg2);
67621     } catch (std::out_of_range& e) {
67622       {
67623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67624       };
67625     } catch (std::exception& e) {
67626       {
67627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67628       };
67629     } catch (Dali::DaliException e) {
67630       {
67631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67632       };
67633     } catch (...) {
67634       {
67635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67636       };
67637     }
67638   }
67639
67640
67641   //argout typemap for const std::string&
67642
67643 }
67644
67645
67646 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
67647   char * jresult ;
67648   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67649   std::string *result = 0 ;
67650
67651   arg1 = (Dali::Toolkit::Control *)jarg1;
67652   {
67653     try {
67654       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
67655     } catch (std::out_of_range& e) {
67656       {
67657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67658       };
67659     } catch (std::exception& e) {
67660       {
67661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67662       };
67663     } catch (Dali::DaliException e) {
67664       {
67665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67666       };
67667     } catch (...) {
67668       {
67669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67670       };
67671     }
67672   }
67673
67674   jresult = SWIG_csharp_string_callback(result->c_str());
67675   return jresult;
67676 }
67677
67678
67679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
67680   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67681   Dali::Vector4 *arg2 = 0 ;
67682
67683   arg1 = (Dali::Toolkit::Control *)jarg1;
67684   arg2 = (Dali::Vector4 *)jarg2;
67685   if (!arg2) {
67686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67687     return ;
67688   }
67689   {
67690     try {
67691       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
67692     } catch (std::out_of_range& e) {
67693       {
67694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67695       };
67696     } catch (std::exception& e) {
67697       {
67698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67699       };
67700     } catch (Dali::DaliException e) {
67701       {
67702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67703       };
67704     } catch (...) {
67705       {
67706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67707       };
67708     }
67709   }
67710
67711 }
67712
67713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
67714   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67715
67716   arg1 = (Dali::Toolkit::Control *)jarg1;
67717   {
67718     try {
67719       (arg1)->ClearBackground();
67720     } catch (std::out_of_range& e) {
67721       {
67722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67723       };
67724     } catch (std::exception& e) {
67725       {
67726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67727       };
67728     } catch (Dali::DaliException e) {
67729       {
67730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67731       };
67732     } catch (...) {
67733       {
67734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67735       };
67736     }
67737   }
67738
67739 }
67740
67741
67742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
67743   void * jresult ;
67744   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67745   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
67746
67747   arg1 = (Dali::Toolkit::Control *)jarg1;
67748   {
67749     try {
67750       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
67751     } catch (std::out_of_range& e) {
67752       {
67753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67754       };
67755     } catch (std::exception& e) {
67756       {
67757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67758       };
67759     } catch (Dali::DaliException e) {
67760       {
67761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67762       };
67763     } catch (...) {
67764       {
67765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67766       };
67767     }
67768   }
67769
67770   jresult = (void *)result;
67771   return jresult;
67772 }
67773
67774
67775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
67776   void * jresult ;
67777   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67778   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67779
67780   arg1 = (Dali::Toolkit::Control *)jarg1;
67781   {
67782     try {
67783       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
67784     } catch (std::out_of_range& e) {
67785       {
67786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67787       };
67788     } catch (std::exception& e) {
67789       {
67790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67791       };
67792     } catch (Dali::DaliException e) {
67793       {
67794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67795       };
67796     } catch (...) {
67797       {
67798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67799       };
67800     }
67801   }
67802
67803   jresult = (void *)result;
67804   return jresult;
67805 }
67806
67807
67808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
67809   void * jresult ;
67810   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67811   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67812
67813   arg1 = (Dali::Toolkit::Control *)jarg1;
67814   {
67815     try {
67816       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
67817     } catch (std::out_of_range& e) {
67818       {
67819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67820       };
67821     } catch (std::exception& e) {
67822       {
67823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67824       };
67825     } catch (Dali::DaliException e) {
67826       {
67827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67828       };
67829     } catch (...) {
67830       {
67831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67832       };
67833     }
67834   }
67835
67836   jresult = (void *)result;
67837   return jresult;
67838 }
67839
67840
67841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
67842   void * jresult ;
67843   Dali::Toolkit::Internal::Control *arg1 = 0 ;
67844   Dali::Toolkit::Control *result = 0 ;
67845
67846   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67847   if (!arg1) {
67848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
67849     return 0;
67850   }
67851   {
67852     try {
67853       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
67854     } catch (std::out_of_range& e) {
67855       {
67856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67857       };
67858     } catch (std::exception& e) {
67859       {
67860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67861       };
67862     } catch (Dali::DaliException e) {
67863       {
67864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67865       };
67866     } catch (...) {
67867       {
67868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67869       };
67870     }
67871   }
67872
67873   jresult = (void *)result;
67874   return jresult;
67875 }
67876
67877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
67878 {
67879   int jresult;
67880   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67881   arg1 = (Dali::Toolkit::Control *)jarg1;
67882
67883   if (!arg1) {
67884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67885     return 0;
67886   }
67887
67888   Dali::Property::Index arg2 = 0 ;
67889   arg2 = (Dali::Property::Index)jarg2;
67890
67891   Toolkit::Visual::ResourceStatus result;
67892   {
67893     try {
67894       result = arg1->GetVisualResourceStatus(arg2);
67895     } catch (std::out_of_range& e) {
67896       {
67897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67898       };
67899     } catch (std::exception& e) {
67900       {
67901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67902       };
67903     } catch (...) {
67904       {
67905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67906       };
67907     }
67908   }
67909   jresult = (int)(result);
67910   return jresult;
67911 }
67912
67913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
67914 {
67915   void * jresult;
67916   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67917   arg1 = (Dali::Toolkit::Control *)jarg1;
67918
67919   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
67920
67921   Dali::Toolkit::TransitionData *arg2 = 0 ;
67922   Dali::Animation result;
67923
67924   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
67925   if (!arg2) {
67926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
67927     return 0;
67928   }
67929   {
67930     try {
67931       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
67932     } catch (std::out_of_range& e) {
67933       {
67934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67935       };
67936     } catch (std::exception& e) {
67937       {
67938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67939       };
67940     } catch (Dali::DaliException e) {
67941       {
67942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67943       };
67944     } catch (...) {
67945       {
67946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67947       };
67948     }
67949   }
67950
67951   jresult = new Dali::Animation((const Dali::Animation &)result);
67952   return jresult;
67953 }
67954
67955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
67956 {
67957   Dali::Toolkit::Control arg1;
67958   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
67959
67960   if (!argp1) {
67961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67962   }
67963   arg1 = *argp1;
67964
67965   Dali::Property::Index arg2 = 0 ;
67966   arg2 = (Dali::Property::Index)jarg2;
67967
67968   Dali::Property::Index arg3 = 0 ;
67969   arg3 = (Dali::Property::Index)jarg3;
67970
67971   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
67972
67973   {
67974     try {
67975       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
67976     } catch (std::out_of_range& e) {
67977       {
67978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67979       };
67980     } catch (std::exception& e) {
67981       {
67982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67983       };
67984     } catch (...) {
67985       {
67986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67987       };
67988     }
67989   }
67990
67991
67992 }
67993
67994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
67995   void * jresult ;
67996   Dali::Toolkit::Control *arg1 = 0 ;
67997   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
67998
67999   arg1 = (Dali::Toolkit::Control *)jarg1;
68000   if (!arg1) {
68001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68002     return 0;
68003   }
68004   {
68005     try {
68006       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68007     } catch (std::out_of_range& e) {
68008       {
68009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68010       };
68011     } catch (std::exception& e) {
68012       {
68013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68014       };
68015     } catch (Dali::DaliException e) {
68016       {
68017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68018       };
68019     } catch (...) {
68020       {
68021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68022       };
68023     }
68024   }
68025
68026   jresult = (void *)result;
68027   return jresult;
68028 }
68029
68030
68031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68032   unsigned int jresult ;
68033   Dali::Toolkit::Control *arg1 = 0 ;
68034   bool result;
68035
68036   arg1 = (Dali::Toolkit::Control *)jarg1;
68037   if (!arg1) {
68038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68039     return 0;
68040   }
68041   {
68042     try {
68043       result = (bool)arg1->IsResourceReady();
68044     } catch (std::out_of_range& e) {
68045       {
68046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68047       };
68048     } catch (std::exception& e) {
68049       {
68050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68051       };
68052     } catch (Dali::DaliException e) {
68053       {
68054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68055       };
68056     } catch (...) {
68057       {
68058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68059       };
68060     }
68061   }
68062
68063   jresult = result;
68064   return jresult;
68065 }
68066
68067
68068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68069   void * jresult ;
68070   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68071
68072   {
68073     try {
68074       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68075     } catch (std::out_of_range& e) {
68076       {
68077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68078       };
68079     } catch (std::exception& e) {
68080       {
68081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68082       };
68083     } catch (Dali::DaliException e) {
68084       {
68085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68086       };
68087     } catch (...) {
68088       {
68089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68090       };
68091     }
68092   }
68093
68094   jresult = (void *)result;
68095   return jresult;
68096 }
68097
68098
68099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68100   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68101
68102   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68103   {
68104     try {
68105       delete arg1;
68106     } catch (std::out_of_range& e) {
68107       {
68108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68109       };
68110     } catch (std::exception& e) {
68111       {
68112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68113       };
68114     } catch (Dali::DaliException e) {
68115       {
68116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68117       };
68118     } catch (...) {
68119       {
68120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68121       };
68122     }
68123   }
68124
68125 }
68126
68127
68128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68129   void * jresult ;
68130   Dali::Toolkit::KeyInputFocusManager result;
68131
68132   {
68133     try {
68134       result = Dali::Toolkit::KeyInputFocusManager::Get();
68135     } catch (std::out_of_range& e) {
68136       {
68137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68138       };
68139     } catch (std::exception& e) {
68140       {
68141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68142       };
68143     } catch (Dali::DaliException e) {
68144       {
68145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68146       };
68147     } catch (...) {
68148       {
68149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68150       };
68151     }
68152   }
68153
68154   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68155   return jresult;
68156 }
68157
68158
68159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68160   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68161   Dali::Toolkit::Control arg2 ;
68162   Dali::Toolkit::Control *argp2 ;
68163
68164   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68165   argp2 = (Dali::Toolkit::Control *)jarg2;
68166   if (!argp2) {
68167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68168     return ;
68169   }
68170   arg2 = *argp2;
68171   {
68172     try {
68173       (arg1)->SetFocus(arg2);
68174     } catch (std::out_of_range& e) {
68175       {
68176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68177       };
68178     } catch (std::exception& e) {
68179       {
68180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68181       };
68182     } catch (Dali::DaliException e) {
68183       {
68184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68185       };
68186     } catch (...) {
68187       {
68188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68189       };
68190     }
68191   }
68192
68193 }
68194
68195
68196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68197   void * jresult ;
68198   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68199   Dali::Toolkit::Control result;
68200
68201   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68202   {
68203     try {
68204       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68205     } catch (std::out_of_range& e) {
68206       {
68207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68208       };
68209     } catch (std::exception& e) {
68210       {
68211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68212       };
68213     } catch (Dali::DaliException e) {
68214       {
68215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68216       };
68217     } catch (...) {
68218       {
68219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68220       };
68221     }
68222   }
68223
68224   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68225   return jresult;
68226 }
68227
68228
68229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68230   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68231   Dali::Toolkit::Control arg2 ;
68232   Dali::Toolkit::Control *argp2 ;
68233
68234   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68235   argp2 = (Dali::Toolkit::Control *)jarg2;
68236   if (!argp2) {
68237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68238     return ;
68239   }
68240   arg2 = *argp2;
68241   {
68242     try {
68243       (arg1)->RemoveFocus(arg2);
68244     } catch (std::out_of_range& e) {
68245       {
68246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68247       };
68248     } catch (std::exception& e) {
68249       {
68250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68251       };
68252     } catch (Dali::DaliException e) {
68253       {
68254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68255       };
68256     } catch (...) {
68257       {
68258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68259       };
68260     }
68261   }
68262
68263 }
68264
68265
68266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68267   void * jresult ;
68268   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68269   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68270
68271   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68272   {
68273     try {
68274       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68275     } catch (std::out_of_range& e) {
68276       {
68277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68278       };
68279     } catch (std::exception& e) {
68280       {
68281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68282       };
68283     } catch (Dali::DaliException e) {
68284       {
68285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68286       };
68287     } catch (...) {
68288       {
68289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68290       };
68291     }
68292   }
68293
68294   jresult = (void *)result;
68295   return jresult;
68296 }
68297
68298
68299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68300   void * jresult ;
68301   Dali::Toolkit::Alignment::Padding *result = 0 ;
68302
68303   {
68304     try {
68305       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68306     } catch (std::out_of_range& e) {
68307       {
68308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68309       };
68310     } catch (std::exception& e) {
68311       {
68312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68313       };
68314     } catch (Dali::DaliException e) {
68315       {
68316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68317       };
68318     } catch (...) {
68319       {
68320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68321       };
68322     }
68323   }
68324
68325   jresult = (void *)result;
68326   return jresult;
68327 }
68328
68329
68330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68331   void * jresult ;
68332   float arg1 ;
68333   float arg2 ;
68334   float arg3 ;
68335   float arg4 ;
68336   Dali::Toolkit::Alignment::Padding *result = 0 ;
68337
68338   arg1 = (float)jarg1;
68339   arg2 = (float)jarg2;
68340   arg3 = (float)jarg3;
68341   arg4 = (float)jarg4;
68342   {
68343     try {
68344       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68345     } catch (std::out_of_range& e) {
68346       {
68347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68348       };
68349     } catch (std::exception& e) {
68350       {
68351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68352       };
68353     } catch (Dali::DaliException e) {
68354       {
68355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68356       };
68357     } catch (...) {
68358       {
68359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68360       };
68361     }
68362   }
68363
68364   jresult = (void *)result;
68365   return jresult;
68366 }
68367
68368
68369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68370   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68371   float arg2 ;
68372
68373   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68374   arg2 = (float)jarg2;
68375   if (arg1) (arg1)->left = arg2;
68376 }
68377
68378
68379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68380   float jresult ;
68381   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68382   float result;
68383
68384   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68385   result = (float) ((arg1)->left);
68386   jresult = result;
68387   return jresult;
68388 }
68389
68390
68391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68392   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68393   float arg2 ;
68394
68395   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68396   arg2 = (float)jarg2;
68397   if (arg1) (arg1)->right = arg2;
68398 }
68399
68400
68401 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68402   float jresult ;
68403   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68404   float result;
68405
68406   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68407   result = (float) ((arg1)->right);
68408   jresult = result;
68409   return jresult;
68410 }
68411
68412
68413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68414   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68415   float arg2 ;
68416
68417   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68418   arg2 = (float)jarg2;
68419   if (arg1) (arg1)->top = arg2;
68420 }
68421
68422
68423 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68424   float jresult ;
68425   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68426   float result;
68427
68428   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68429   result = (float) ((arg1)->top);
68430   jresult = result;
68431   return jresult;
68432 }
68433
68434
68435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68436   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68437   float arg2 ;
68438
68439   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68440   arg2 = (float)jarg2;
68441   if (arg1) (arg1)->bottom = arg2;
68442 }
68443
68444
68445 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68446   float jresult ;
68447   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68448   float result;
68449
68450   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68451   result = (float) ((arg1)->bottom);
68452   jresult = result;
68453   return jresult;
68454 }
68455
68456
68457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68458   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68459
68460   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68461   {
68462     try {
68463       delete arg1;
68464     } catch (std::out_of_range& e) {
68465       {
68466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68467       };
68468     } catch (std::exception& e) {
68469       {
68470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68471       };
68472     } catch (Dali::DaliException e) {
68473       {
68474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68475       };
68476     } catch (...) {
68477       {
68478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68479       };
68480     }
68481   }
68482
68483 }
68484
68485
68486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68487   void * jresult ;
68488   Dali::Toolkit::Alignment *result = 0 ;
68489
68490   {
68491     try {
68492       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68493     } catch (std::out_of_range& e) {
68494       {
68495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68496       };
68497     } catch (std::exception& e) {
68498       {
68499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68500       };
68501     } catch (Dali::DaliException e) {
68502       {
68503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68504       };
68505     } catch (...) {
68506       {
68507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68508       };
68509     }
68510   }
68511
68512   jresult = (void *)result;
68513   return jresult;
68514 }
68515
68516
68517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68518   void * jresult ;
68519   Dali::Toolkit::Alignment::Type arg1 ;
68520   Dali::Toolkit::Alignment::Type arg2 ;
68521   Dali::Toolkit::Alignment result;
68522
68523   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68524   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68525   {
68526     try {
68527       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68528     } catch (std::out_of_range& e) {
68529       {
68530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68531       };
68532     } catch (std::exception& e) {
68533       {
68534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68535       };
68536     } catch (Dali::DaliException e) {
68537       {
68538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68539       };
68540     } catch (...) {
68541       {
68542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68543       };
68544     }
68545   }
68546
68547   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68548   return jresult;
68549 }
68550
68551
68552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
68553   void * jresult ;
68554   Dali::Toolkit::Alignment::Type arg1 ;
68555   Dali::Toolkit::Alignment result;
68556
68557   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68558   {
68559     try {
68560       result = Dali::Toolkit::Alignment::New(arg1);
68561     } catch (std::out_of_range& e) {
68562       {
68563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68564       };
68565     } catch (std::exception& e) {
68566       {
68567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68568       };
68569     } catch (Dali::DaliException e) {
68570       {
68571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68572       };
68573     } catch (...) {
68574       {
68575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68576       };
68577     }
68578   }
68579
68580   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68581   return jresult;
68582 }
68583
68584
68585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
68586   void * jresult ;
68587   Dali::Toolkit::Alignment result;
68588
68589   {
68590     try {
68591       result = Dali::Toolkit::Alignment::New();
68592     } catch (std::out_of_range& e) {
68593       {
68594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68595       };
68596     } catch (std::exception& e) {
68597       {
68598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68599       };
68600     } catch (Dali::DaliException e) {
68601       {
68602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68603       };
68604     } catch (...) {
68605       {
68606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68607       };
68608     }
68609   }
68610
68611   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68612   return jresult;
68613 }
68614
68615
68616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
68617   void * jresult ;
68618   Dali::Toolkit::Alignment *arg1 = 0 ;
68619   Dali::Toolkit::Alignment *result = 0 ;
68620
68621   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68622   if (!arg1) {
68623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68624     return 0;
68625   }
68626   {
68627     try {
68628       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
68629     } catch (std::out_of_range& e) {
68630       {
68631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68632       };
68633     } catch (std::exception& e) {
68634       {
68635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68636       };
68637     } catch (Dali::DaliException e) {
68638       {
68639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68640       };
68641     } catch (...) {
68642       {
68643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68644       };
68645     }
68646   }
68647
68648   jresult = (void *)result;
68649   return jresult;
68650 }
68651
68652
68653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
68654   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68655
68656   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68657   {
68658     try {
68659       delete arg1;
68660     } catch (std::out_of_range& e) {
68661       {
68662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68663       };
68664     } catch (std::exception& e) {
68665       {
68666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68667       };
68668     } catch (Dali::DaliException e) {
68669       {
68670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68671       };
68672     } catch (...) {
68673       {
68674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68675       };
68676     }
68677   }
68678
68679 }
68680
68681
68682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
68683   void * jresult ;
68684   Dali::BaseHandle arg1 ;
68685   Dali::BaseHandle *argp1 ;
68686   Dali::Toolkit::Alignment result;
68687
68688   argp1 = (Dali::BaseHandle *)jarg1;
68689   if (!argp1) {
68690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68691     return 0;
68692   }
68693   arg1 = *argp1;
68694   {
68695     try {
68696       result = Dali::Toolkit::Alignment::DownCast(arg1);
68697     } catch (std::out_of_range& e) {
68698       {
68699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68700       };
68701     } catch (std::exception& e) {
68702       {
68703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68704       };
68705     } catch (Dali::DaliException e) {
68706       {
68707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68708       };
68709     } catch (...) {
68710       {
68711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68712       };
68713     }
68714   }
68715
68716   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68717   return jresult;
68718 }
68719
68720
68721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
68722   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68723   Dali::Toolkit::Alignment::Type arg2 ;
68724
68725   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68726   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68727   {
68728     try {
68729       (arg1)->SetAlignmentType(arg2);
68730     } catch (std::out_of_range& e) {
68731       {
68732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68733       };
68734     } catch (std::exception& e) {
68735       {
68736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68737       };
68738     } catch (Dali::DaliException e) {
68739       {
68740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68741       };
68742     } catch (...) {
68743       {
68744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68745       };
68746     }
68747   }
68748
68749 }
68750
68751
68752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
68753   int jresult ;
68754   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68755   Dali::Toolkit::Alignment::Type result;
68756
68757   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68758   {
68759     try {
68760       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
68761     } catch (std::out_of_range& e) {
68762       {
68763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68764       };
68765     } catch (std::exception& e) {
68766       {
68767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68768       };
68769     } catch (Dali::DaliException e) {
68770       {
68771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68772       };
68773     } catch (...) {
68774       {
68775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68776       };
68777     }
68778   }
68779
68780   jresult = (int)result;
68781   return jresult;
68782 }
68783
68784
68785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
68786   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68787   Dali::Toolkit::Alignment::Scaling arg2 ;
68788
68789   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68790   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
68791   {
68792     try {
68793       (arg1)->SetScaling(arg2);
68794     } catch (std::out_of_range& e) {
68795       {
68796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68797       };
68798     } catch (std::exception& e) {
68799       {
68800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68801       };
68802     } catch (Dali::DaliException e) {
68803       {
68804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68805       };
68806     } catch (...) {
68807       {
68808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68809       };
68810     }
68811   }
68812
68813 }
68814
68815
68816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
68817   int jresult ;
68818   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68819   Dali::Toolkit::Alignment::Scaling result;
68820
68821   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68822   {
68823     try {
68824       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
68825     } catch (std::out_of_range& e) {
68826       {
68827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68828       };
68829     } catch (std::exception& e) {
68830       {
68831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68832       };
68833     } catch (Dali::DaliException e) {
68834       {
68835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68836       };
68837     } catch (...) {
68838       {
68839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68840       };
68841     }
68842   }
68843
68844   jresult = (int)result;
68845   return jresult;
68846 }
68847
68848
68849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
68850   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68851   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
68852
68853   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68854   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
68855   if (!arg2) {
68856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
68857     return ;
68858   }
68859   {
68860     try {
68861       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
68862     } catch (std::out_of_range& e) {
68863       {
68864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68865       };
68866     } catch (std::exception& e) {
68867       {
68868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68869       };
68870     } catch (Dali::DaliException e) {
68871       {
68872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68873       };
68874     } catch (...) {
68875       {
68876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68877       };
68878     }
68879   }
68880
68881 }
68882
68883
68884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
68885   void * jresult ;
68886   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68887   Dali::Toolkit::Alignment::Padding *result = 0 ;
68888
68889   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68890   {
68891     try {
68892       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
68893     } catch (std::out_of_range& e) {
68894       {
68895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68896       };
68897     } catch (std::exception& e) {
68898       {
68899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68900       };
68901     } catch (Dali::DaliException e) {
68902       {
68903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68904       };
68905     } catch (...) {
68906       {
68907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68908       };
68909     }
68910   }
68911
68912   jresult = (void *)result;
68913   return jresult;
68914 }
68915
68916
68917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
68918   void * jresult ;
68919   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68920   Dali::Toolkit::Alignment *arg2 = 0 ;
68921   Dali::Toolkit::Alignment *result = 0 ;
68922
68923   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68924   arg2 = (Dali::Toolkit::Alignment *)jarg2;
68925   if (!arg2) {
68926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68927     return 0;
68928   }
68929   {
68930     try {
68931       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
68932     } catch (std::out_of_range& e) {
68933       {
68934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68935       };
68936     } catch (std::exception& e) {
68937       {
68938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68939       };
68940     } catch (Dali::DaliException e) {
68941       {
68942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68943       };
68944     } catch (...) {
68945       {
68946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68947       };
68948     }
68949   }
68950
68951   jresult = (void *)result;
68952   return jresult;
68953 }
68954
68955
68956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
68957   int jresult ;
68958   int result;
68959
68960   result = (int)Dali::Toolkit::Button::Property::DISABLED;
68961   jresult = (int)result;
68962   return jresult;
68963 }
68964
68965
68966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
68967   int jresult ;
68968   int result;
68969
68970   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
68971   jresult = (int)result;
68972   return jresult;
68973 }
68974
68975
68976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
68977   int jresult ;
68978   int result;
68979
68980   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
68981   jresult = (int)result;
68982   return jresult;
68983 }
68984
68985
68986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
68987   int jresult ;
68988   int result;
68989
68990   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
68991   jresult = (int)result;
68992   return jresult;
68993 }
68994
68995
68996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
68997   int jresult ;
68998   int result;
68999
69000   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69001   jresult = (int)result;
69002   return jresult;
69003 }
69004
69005
69006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69007   int jresult ;
69008   int result;
69009
69010   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69011   jresult = (int)result;
69012   return jresult;
69013 }
69014
69015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69016   int jresult ;
69017   int result;
69018
69019   result = (int)Dali::Toolkit::Button::Property::LABEL;
69020   jresult = (int)result;
69021   return jresult;
69022 }
69023
69024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69025   void * jresult ;
69026   Dali::Toolkit::Button::Property *result = 0 ;
69027
69028   {
69029     try {
69030       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69031     } catch (std::out_of_range& e) {
69032       {
69033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69034       };
69035     } catch (std::exception& e) {
69036       {
69037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69038       };
69039     } catch (Dali::DaliException e) {
69040       {
69041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69042       };
69043     } catch (...) {
69044       {
69045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69046       };
69047     }
69048   }
69049
69050   jresult = (void *)result;
69051   return jresult;
69052 }
69053
69054
69055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69056   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69057
69058   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69059   {
69060     try {
69061       delete arg1;
69062     } catch (std::out_of_range& e) {
69063       {
69064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69065       };
69066     } catch (std::exception& e) {
69067       {
69068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69069       };
69070     } catch (Dali::DaliException e) {
69071       {
69072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69073       };
69074     } catch (...) {
69075       {
69076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69077       };
69078     }
69079   }
69080
69081 }
69082
69083
69084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69085   void * jresult ;
69086   Dali::Toolkit::Button *result = 0 ;
69087
69088   {
69089     try {
69090       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69091     } catch (std::out_of_range& e) {
69092       {
69093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69094       };
69095     } catch (std::exception& e) {
69096       {
69097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69098       };
69099     } catch (Dali::DaliException e) {
69100       {
69101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69102       };
69103     } catch (...) {
69104       {
69105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69106       };
69107     }
69108   }
69109
69110   jresult = (void *)result;
69111   return jresult;
69112 }
69113
69114
69115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69116   void * jresult ;
69117   Dali::Toolkit::Button *arg1 = 0 ;
69118   Dali::Toolkit::Button *result = 0 ;
69119
69120   arg1 = (Dali::Toolkit::Button *)jarg1;
69121   if (!arg1) {
69122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69123     return 0;
69124   }
69125   {
69126     try {
69127       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69128     } catch (std::out_of_range& e) {
69129       {
69130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69131       };
69132     } catch (std::exception& e) {
69133       {
69134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69135       };
69136     } catch (Dali::DaliException e) {
69137       {
69138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69139       };
69140     } catch (...) {
69141       {
69142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69143       };
69144     }
69145   }
69146
69147   jresult = (void *)result;
69148   return jresult;
69149 }
69150
69151
69152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69153   void * jresult ;
69154   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69155   Dali::Toolkit::Button *arg2 = 0 ;
69156   Dali::Toolkit::Button *result = 0 ;
69157
69158   arg1 = (Dali::Toolkit::Button *)jarg1;
69159   arg2 = (Dali::Toolkit::Button *)jarg2;
69160   if (!arg2) {
69161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69162     return 0;
69163   }
69164   {
69165     try {
69166       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69167     } catch (std::out_of_range& e) {
69168       {
69169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69170       };
69171     } catch (std::exception& e) {
69172       {
69173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69174       };
69175     } catch (Dali::DaliException e) {
69176       {
69177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69178       };
69179     } catch (...) {
69180       {
69181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69182       };
69183     }
69184   }
69185
69186   jresult = (void *)result;
69187   return jresult;
69188 }
69189
69190
69191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69192   void * jresult ;
69193   Dali::BaseHandle arg1 ;
69194   Dali::BaseHandle *argp1 ;
69195   Dali::Toolkit::Button result;
69196
69197   argp1 = (Dali::BaseHandle *)jarg1;
69198   if (!argp1) {
69199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69200     return 0;
69201   }
69202   arg1 = *argp1;
69203   {
69204     try {
69205       result = Dali::Toolkit::Button::DownCast(arg1);
69206     } catch (std::out_of_range& e) {
69207       {
69208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69209       };
69210     } catch (std::exception& e) {
69211       {
69212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69213       };
69214     } catch (Dali::DaliException e) {
69215       {
69216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69217       };
69218     } catch (...) {
69219       {
69220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69221       };
69222     }
69223   }
69224
69225   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69226   return jresult;
69227 }
69228
69229
69230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69231   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69232
69233   arg1 = (Dali::Toolkit::Button *)jarg1;
69234   {
69235     try {
69236       delete arg1;
69237     } catch (std::out_of_range& e) {
69238       {
69239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69240       };
69241     } catch (std::exception& e) {
69242       {
69243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69244       };
69245     } catch (Dali::DaliException e) {
69246       {
69247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69248       };
69249     } catch (...) {
69250       {
69251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69252       };
69253     }
69254   }
69255
69256 }
69257
69258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
69259   void * jresult ;
69260   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69261   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69262
69263   arg1 = (Dali::Toolkit::Button *)jarg1;
69264   {
69265     try {
69266       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
69267     } catch (std::out_of_range& e) {
69268       {
69269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69270       };
69271     } catch (std::exception& e) {
69272       {
69273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69274       };
69275     } catch (Dali::DaliException e) {
69276       {
69277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69278       };
69279     } catch (...) {
69280       {
69281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69282       };
69283     }
69284   }
69285
69286   jresult = (void *)result;
69287   return jresult;
69288 }
69289
69290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
69291   void * jresult ;
69292   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69293   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69294
69295   arg1 = (Dali::Toolkit::Button *)jarg1;
69296   {
69297     try {
69298       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
69299     } catch (std::out_of_range& e) {
69300       {
69301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69302       };
69303     } catch (std::exception& e) {
69304       {
69305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69306       };
69307     } catch (Dali::DaliException e) {
69308       {
69309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69310       };
69311     } catch (...) {
69312       {
69313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69314       };
69315     }
69316   }
69317
69318   jresult = (void *)result;
69319   return jresult;
69320 }
69321
69322
69323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
69324   void * jresult ;
69325   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69326   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69327
69328   arg1 = (Dali::Toolkit::Button *)jarg1;
69329   {
69330     try {
69331       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
69332     } catch (std::out_of_range& e) {
69333       {
69334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69335       };
69336     } catch (std::exception& e) {
69337       {
69338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69339       };
69340     } catch (Dali::DaliException e) {
69341       {
69342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69343       };
69344     } catch (...) {
69345       {
69346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69347       };
69348     }
69349   }
69350
69351   jresult = (void *)result;
69352   return jresult;
69353 }
69354
69355
69356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
69357   void * jresult ;
69358   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69359   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69360
69361   arg1 = (Dali::Toolkit::Button *)jarg1;
69362   {
69363     try {
69364       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
69365     } catch (std::out_of_range& e) {
69366       {
69367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69368       };
69369     } catch (std::exception& e) {
69370       {
69371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69372       };
69373     } catch (Dali::DaliException e) {
69374       {
69375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69376       };
69377     } catch (...) {
69378       {
69379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69380       };
69381     }
69382   }
69383
69384   jresult = (void *)result;
69385   return jresult;
69386 }
69387
69388
69389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
69390   void * jresult ;
69391   Dali::Toolkit::CheckBoxButton *result = 0 ;
69392
69393   {
69394     try {
69395       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
69396     } catch (std::out_of_range& e) {
69397       {
69398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69399       };
69400     } catch (std::exception& e) {
69401       {
69402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69403       };
69404     } catch (Dali::DaliException e) {
69405       {
69406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69407       };
69408     } catch (...) {
69409       {
69410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69411       };
69412     }
69413   }
69414
69415   jresult = (void *)result;
69416   return jresult;
69417 }
69418
69419
69420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
69421   void * jresult ;
69422   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
69423   Dali::Toolkit::CheckBoxButton *result = 0 ;
69424
69425   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69426   if (!arg1) {
69427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69428     return 0;
69429   }
69430   {
69431     try {
69432       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
69433     } catch (std::out_of_range& e) {
69434       {
69435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69436       };
69437     } catch (std::exception& e) {
69438       {
69439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69440       };
69441     } catch (Dali::DaliException e) {
69442       {
69443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69444       };
69445     } catch (...) {
69446       {
69447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69448       };
69449     }
69450   }
69451
69452   jresult = (void *)result;
69453   return jresult;
69454 }
69455
69456
69457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
69458   void * jresult ;
69459   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69460   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
69461   Dali::Toolkit::CheckBoxButton *result = 0 ;
69462
69463   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69464   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
69465   if (!arg2) {
69466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69467     return 0;
69468   }
69469   {
69470     try {
69471       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
69472     } catch (std::out_of_range& e) {
69473       {
69474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69475       };
69476     } catch (std::exception& e) {
69477       {
69478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69479       };
69480     } catch (Dali::DaliException e) {
69481       {
69482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69483       };
69484     } catch (...) {
69485       {
69486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69487       };
69488     }
69489   }
69490
69491   jresult = (void *)result;
69492   return jresult;
69493 }
69494
69495
69496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
69497   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69498
69499   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69500   {
69501     try {
69502       delete arg1;
69503     } catch (std::out_of_range& e) {
69504       {
69505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69506       };
69507     } catch (std::exception& e) {
69508       {
69509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69510       };
69511     } catch (Dali::DaliException e) {
69512       {
69513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69514       };
69515     } catch (...) {
69516       {
69517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69518       };
69519     }
69520   }
69521
69522 }
69523
69524
69525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
69526   void * jresult ;
69527   Dali::Toolkit::CheckBoxButton result;
69528
69529   {
69530     try {
69531       result = Dali::Toolkit::CheckBoxButton::New();
69532     } catch (std::out_of_range& e) {
69533       {
69534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69535       };
69536     } catch (std::exception& e) {
69537       {
69538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69539       };
69540     } catch (Dali::DaliException e) {
69541       {
69542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69543       };
69544     } catch (...) {
69545       {
69546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69547       };
69548     }
69549   }
69550
69551   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
69552   return jresult;
69553 }
69554
69555
69556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
69557   void * jresult ;
69558   Dali::BaseHandle arg1 ;
69559   Dali::BaseHandle *argp1 ;
69560   Dali::Toolkit::CheckBoxButton result;
69561
69562   argp1 = (Dali::BaseHandle *)jarg1;
69563   if (!argp1) {
69564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69565     return 0;
69566   }
69567   arg1 = *argp1;
69568   {
69569     try {
69570       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
69571     } catch (std::out_of_range& e) {
69572       {
69573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69574       };
69575     } catch (std::exception& e) {
69576       {
69577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69578       };
69579     } catch (Dali::DaliException e) {
69580       {
69581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69582       };
69583     } catch (...) {
69584       {
69585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69586       };
69587     }
69588   }
69589
69590   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
69591   return jresult;
69592 }
69593
69594
69595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
69596   int jresult ;
69597   int result;
69598
69599   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
69600   jresult = (int)result;
69601   return jresult;
69602 }
69603
69604
69605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
69606   int jresult ;
69607   int result;
69608
69609   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
69610   jresult = (int)result;
69611   return jresult;
69612 }
69613
69614
69615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
69616   int jresult ;
69617   int result;
69618
69619   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
69620   jresult = (int)result;
69621   return jresult;
69622 }
69623
69624
69625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
69626   int jresult ;
69627   int result;
69628
69629   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
69630   jresult = (int)result;
69631   return jresult;
69632 }
69633
69634
69635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
69636   int jresult ;
69637   int result;
69638
69639   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
69640   jresult = (int)result;
69641   return jresult;
69642 }
69643
69644
69645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
69646   void * jresult ;
69647   Dali::Toolkit::PushButton::Property *result = 0 ;
69648
69649   {
69650     try {
69651       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
69652     } catch (std::out_of_range& e) {
69653       {
69654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69655       };
69656     } catch (std::exception& e) {
69657       {
69658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69659       };
69660     } catch (Dali::DaliException e) {
69661       {
69662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69663       };
69664     } catch (...) {
69665       {
69666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69667       };
69668     }
69669   }
69670
69671   jresult = (void *)result;
69672   return jresult;
69673 }
69674
69675
69676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
69677   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
69678
69679   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
69680   {
69681     try {
69682       delete arg1;
69683     } catch (std::out_of_range& e) {
69684       {
69685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69686       };
69687     } catch (std::exception& e) {
69688       {
69689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69690       };
69691     } catch (Dali::DaliException e) {
69692       {
69693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69694       };
69695     } catch (...) {
69696       {
69697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69698       };
69699     }
69700   }
69701
69702 }
69703
69704
69705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
69706   void * jresult ;
69707   Dali::Toolkit::PushButton *result = 0 ;
69708
69709   {
69710     try {
69711       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
69712     } catch (std::out_of_range& e) {
69713       {
69714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69715       };
69716     } catch (std::exception& e) {
69717       {
69718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69719       };
69720     } catch (Dali::DaliException e) {
69721       {
69722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69723       };
69724     } catch (...) {
69725       {
69726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69727       };
69728     }
69729   }
69730
69731   jresult = (void *)result;
69732   return jresult;
69733 }
69734
69735
69736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
69737   void * jresult ;
69738   Dali::Toolkit::PushButton *arg1 = 0 ;
69739   Dali::Toolkit::PushButton *result = 0 ;
69740
69741   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69742   if (!arg1) {
69743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
69744     return 0;
69745   }
69746   {
69747     try {
69748       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
69749     } catch (std::out_of_range& e) {
69750       {
69751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69752       };
69753     } catch (std::exception& e) {
69754       {
69755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69756       };
69757     } catch (Dali::DaliException e) {
69758       {
69759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69760       };
69761     } catch (...) {
69762       {
69763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69764       };
69765     }
69766   }
69767
69768   jresult = (void *)result;
69769   return jresult;
69770 }
69771
69772
69773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
69774   void * jresult ;
69775   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
69776   Dali::Toolkit::PushButton *arg2 = 0 ;
69777   Dali::Toolkit::PushButton *result = 0 ;
69778
69779   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69780   arg2 = (Dali::Toolkit::PushButton *)jarg2;
69781   if (!arg2) {
69782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
69783     return 0;
69784   }
69785   {
69786     try {
69787       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
69788     } catch (std::out_of_range& e) {
69789       {
69790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69791       };
69792     } catch (std::exception& e) {
69793       {
69794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69795       };
69796     } catch (Dali::DaliException e) {
69797       {
69798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69799       };
69800     } catch (...) {
69801       {
69802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69803       };
69804     }
69805   }
69806
69807   jresult = (void *)result;
69808   return jresult;
69809 }
69810
69811
69812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
69813   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
69814
69815   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69816   {
69817     try {
69818       delete arg1;
69819     } catch (std::out_of_range& e) {
69820       {
69821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69822       };
69823     } catch (std::exception& e) {
69824       {
69825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69826       };
69827     } catch (Dali::DaliException e) {
69828       {
69829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69830       };
69831     } catch (...) {
69832       {
69833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69834       };
69835     }
69836   }
69837
69838 }
69839
69840
69841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
69842   void * jresult ;
69843   Dali::Toolkit::PushButton result;
69844
69845   {
69846     try {
69847       result = Dali::Toolkit::PushButton::New();
69848     } catch (std::out_of_range& e) {
69849       {
69850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69851       };
69852     } catch (std::exception& e) {
69853       {
69854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69855       };
69856     } catch (Dali::DaliException e) {
69857       {
69858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69859       };
69860     } catch (...) {
69861       {
69862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69863       };
69864     }
69865   }
69866
69867   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
69868   return jresult;
69869 }
69870
69871
69872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
69873   void * jresult ;
69874   Dali::BaseHandle arg1 ;
69875   Dali::BaseHandle *argp1 ;
69876   Dali::Toolkit::PushButton result;
69877
69878   argp1 = (Dali::BaseHandle *)jarg1;
69879   if (!argp1) {
69880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69881     return 0;
69882   }
69883   arg1 = *argp1;
69884   {
69885     try {
69886       result = Dali::Toolkit::PushButton::DownCast(arg1);
69887     } catch (std::out_of_range& e) {
69888       {
69889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69890       };
69891     } catch (std::exception& e) {
69892       {
69893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69894       };
69895     } catch (Dali::DaliException e) {
69896       {
69897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69898       };
69899     } catch (...) {
69900       {
69901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69902       };
69903     }
69904   }
69905
69906   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
69907   return jresult;
69908 }
69909
69910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
69911   void * jresult ;
69912   Dali::Toolkit::RadioButton *result = 0 ;
69913
69914   {
69915     try {
69916       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
69917     } catch (std::out_of_range& e) {
69918       {
69919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69920       };
69921     } catch (std::exception& e) {
69922       {
69923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69924       };
69925     } catch (Dali::DaliException e) {
69926       {
69927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69928       };
69929     } catch (...) {
69930       {
69931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69932       };
69933     }
69934   }
69935
69936   jresult = (void *)result;
69937   return jresult;
69938 }
69939
69940
69941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
69942   void * jresult ;
69943   Dali::Toolkit::RadioButton *arg1 = 0 ;
69944   Dali::Toolkit::RadioButton *result = 0 ;
69945
69946   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
69947   if (!arg1) {
69948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
69949     return 0;
69950   }
69951   {
69952     try {
69953       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
69954     } catch (std::out_of_range& e) {
69955       {
69956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69957       };
69958     } catch (std::exception& e) {
69959       {
69960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69961       };
69962     } catch (Dali::DaliException e) {
69963       {
69964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69965       };
69966     } catch (...) {
69967       {
69968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69969       };
69970     }
69971   }
69972
69973   jresult = (void *)result;
69974   return jresult;
69975 }
69976
69977
69978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
69979   void * jresult ;
69980   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
69981   Dali::Toolkit::RadioButton *arg2 = 0 ;
69982   Dali::Toolkit::RadioButton *result = 0 ;
69983
69984   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
69985   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
69986   if (!arg2) {
69987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
69988     return 0;
69989   }
69990   {
69991     try {
69992       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
69993     } catch (std::out_of_range& e) {
69994       {
69995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69996       };
69997     } catch (std::exception& e) {
69998       {
69999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70000       };
70001     } catch (Dali::DaliException e) {
70002       {
70003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70004       };
70005     } catch (...) {
70006       {
70007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70008       };
70009     }
70010   }
70011
70012   jresult = (void *)result;
70013   return jresult;
70014 }
70015
70016
70017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
70018   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
70019
70020   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70021   {
70022     try {
70023       delete arg1;
70024     } catch (std::out_of_range& e) {
70025       {
70026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70027       };
70028     } catch (std::exception& e) {
70029       {
70030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70031       };
70032     } catch (Dali::DaliException e) {
70033       {
70034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70035       };
70036     } catch (...) {
70037       {
70038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70039       };
70040     }
70041   }
70042
70043 }
70044
70045
70046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
70047   void * jresult ;
70048   Dali::Toolkit::RadioButton result;
70049
70050   {
70051     try {
70052       result = Dali::Toolkit::RadioButton::New();
70053     } catch (std::out_of_range& e) {
70054       {
70055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70056       };
70057     } catch (std::exception& e) {
70058       {
70059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70060       };
70061     } catch (Dali::DaliException e) {
70062       {
70063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70064       };
70065     } catch (...) {
70066       {
70067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70068       };
70069     }
70070   }
70071
70072   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70073   return jresult;
70074 }
70075
70076
70077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
70078   void * jresult ;
70079   std::string *arg1 = 0 ;
70080   Dali::Toolkit::RadioButton result;
70081
70082   if (!jarg1) {
70083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70084     return 0;
70085   }
70086   std::string arg1_str(jarg1);
70087   arg1 = &arg1_str;
70088   {
70089     try {
70090       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
70091     } catch (std::out_of_range& e) {
70092       {
70093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70094       };
70095     } catch (std::exception& e) {
70096       {
70097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70098       };
70099     } catch (Dali::DaliException e) {
70100       {
70101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70102       };
70103     } catch (...) {
70104       {
70105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70106       };
70107     }
70108   }
70109
70110   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70111
70112   //argout typemap for const std::string&
70113
70114   return jresult;
70115 }
70116
70117
70118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
70119   void * jresult ;
70120   Dali::BaseHandle arg1 ;
70121   Dali::BaseHandle *argp1 ;
70122   Dali::Toolkit::RadioButton result;
70123
70124   argp1 = (Dali::BaseHandle *)jarg1;
70125   if (!argp1) {
70126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70127     return 0;
70128   }
70129   arg1 = *argp1;
70130   {
70131     try {
70132       result = Dali::Toolkit::RadioButton::DownCast(arg1);
70133     } catch (std::out_of_range& e) {
70134       {
70135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70136       };
70137     } catch (std::exception& e) {
70138       {
70139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70140       };
70141     } catch (Dali::DaliException e) {
70142       {
70143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70144       };
70145     } catch (...) {
70146       {
70147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70148       };
70149     }
70150   }
70151
70152   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70153   return jresult;
70154 }
70155
70156
70157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
70158   int jresult ;
70159   int result;
70160
70161   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
70162   jresult = (int)result;
70163   return jresult;
70164 }
70165
70166
70167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
70168   int jresult ;
70169   int result;
70170
70171   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
70172   jresult = (int)result;
70173   return jresult;
70174 }
70175
70176
70177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
70178   int jresult ;
70179   int result;
70180
70181   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
70182   jresult = (int)result;
70183   return jresult;
70184 }
70185
70186
70187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
70188   int jresult ;
70189   int result;
70190
70191   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
70192   jresult = (int)result;
70193   return jresult;
70194 }
70195
70196
70197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
70198   int jresult ;
70199   int result;
70200
70201   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
70202   jresult = (int)result;
70203   return jresult;
70204 }
70205
70206
70207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
70208   int jresult ;
70209   int result;
70210
70211   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
70212   jresult = (int)result;
70213   return jresult;
70214 }
70215
70216
70217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
70218   void * jresult ;
70219   Dali::Toolkit::FlexContainer::Property *result = 0 ;
70220
70221   {
70222     try {
70223       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
70224     } catch (std::out_of_range& e) {
70225       {
70226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70227       };
70228     } catch (std::exception& e) {
70229       {
70230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70231       };
70232     } catch (Dali::DaliException e) {
70233       {
70234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70235       };
70236     } catch (...) {
70237       {
70238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70239       };
70240     }
70241   }
70242
70243   jresult = (void *)result;
70244   return jresult;
70245 }
70246
70247
70248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
70249   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
70250
70251   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
70252   {
70253     try {
70254       delete arg1;
70255     } catch (std::out_of_range& e) {
70256       {
70257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70258       };
70259     } catch (std::exception& e) {
70260       {
70261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70262       };
70263     } catch (Dali::DaliException e) {
70264       {
70265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70266       };
70267     } catch (...) {
70268       {
70269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70270       };
70271     }
70272   }
70273
70274 }
70275
70276
70277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
70278   int jresult ;
70279   int result;
70280
70281   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
70282   jresult = (int)result;
70283   return jresult;
70284 }
70285
70286
70287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
70288   int jresult ;
70289   int result;
70290
70291   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
70292   jresult = (int)result;
70293   return jresult;
70294 }
70295
70296
70297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
70298   int jresult ;
70299   int result;
70300
70301   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
70302   jresult = (int)result;
70303   return jresult;
70304 }
70305
70306
70307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
70308   void * jresult ;
70309   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
70310
70311   {
70312     try {
70313       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
70314     } catch (std::out_of_range& e) {
70315       {
70316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70317       };
70318     } catch (std::exception& e) {
70319       {
70320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70321       };
70322     } catch (Dali::DaliException e) {
70323       {
70324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70325       };
70326     } catch (...) {
70327       {
70328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70329       };
70330     }
70331   }
70332
70333   jresult = (void *)result;
70334   return jresult;
70335 }
70336
70337
70338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
70339   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
70340
70341   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
70342   {
70343     try {
70344       delete arg1;
70345     } catch (std::out_of_range& e) {
70346       {
70347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70348       };
70349     } catch (std::exception& e) {
70350       {
70351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70352       };
70353     } catch (Dali::DaliException e) {
70354       {
70355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70356       };
70357     } catch (...) {
70358       {
70359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70360       };
70361     }
70362   }
70363
70364 }
70365
70366
70367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
70368   void * jresult ;
70369   Dali::Toolkit::FlexContainer *result = 0 ;
70370
70371   {
70372     try {
70373       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
70374     } catch (std::out_of_range& e) {
70375       {
70376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70377       };
70378     } catch (std::exception& e) {
70379       {
70380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70381       };
70382     } catch (Dali::DaliException e) {
70383       {
70384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70385       };
70386     } catch (...) {
70387       {
70388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70389       };
70390     }
70391   }
70392
70393   jresult = (void *)result;
70394   return jresult;
70395 }
70396
70397
70398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
70399   void * jresult ;
70400   Dali::Toolkit::FlexContainer *arg1 = 0 ;
70401   Dali::Toolkit::FlexContainer *result = 0 ;
70402
70403   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70404   if (!arg1) {
70405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
70406     return 0;
70407   }
70408   {
70409     try {
70410       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
70411     } catch (std::out_of_range& e) {
70412       {
70413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70414       };
70415     } catch (std::exception& e) {
70416       {
70417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70418       };
70419     } catch (Dali::DaliException e) {
70420       {
70421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70422       };
70423     } catch (...) {
70424       {
70425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70426       };
70427     }
70428   }
70429
70430   jresult = (void *)result;
70431   return jresult;
70432 }
70433
70434
70435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
70436   void * jresult ;
70437   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
70438   Dali::Toolkit::FlexContainer *arg2 = 0 ;
70439   Dali::Toolkit::FlexContainer *result = 0 ;
70440
70441   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70442   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
70443   if (!arg2) {
70444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
70445     return 0;
70446   }
70447   {
70448     try {
70449       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
70450     } catch (std::out_of_range& e) {
70451       {
70452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70453       };
70454     } catch (std::exception& e) {
70455       {
70456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70457       };
70458     } catch (Dali::DaliException e) {
70459       {
70460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70461       };
70462     } catch (...) {
70463       {
70464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70465       };
70466     }
70467   }
70468
70469   jresult = (void *)result;
70470   return jresult;
70471 }
70472
70473
70474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
70475   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
70476
70477   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70478   {
70479     try {
70480       delete arg1;
70481     } catch (std::out_of_range& e) {
70482       {
70483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70484       };
70485     } catch (std::exception& e) {
70486       {
70487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70488       };
70489     } catch (Dali::DaliException e) {
70490       {
70491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70492       };
70493     } catch (...) {
70494       {
70495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70496       };
70497     }
70498   }
70499
70500 }
70501
70502
70503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
70504   void * jresult ;
70505   Dali::Toolkit::FlexContainer result;
70506
70507   {
70508     try {
70509       result = Dali::Toolkit::FlexContainer::New();
70510     } catch (std::out_of_range& e) {
70511       {
70512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70513       };
70514     } catch (std::exception& e) {
70515       {
70516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70517       };
70518     } catch (Dali::DaliException e) {
70519       {
70520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70521       };
70522     } catch (...) {
70523       {
70524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70525       };
70526     }
70527   }
70528
70529   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
70530   return jresult;
70531 }
70532
70533
70534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
70535   void * jresult ;
70536   Dali::BaseHandle arg1 ;
70537   Dali::BaseHandle *argp1 ;
70538   Dali::Toolkit::FlexContainer result;
70539
70540   argp1 = (Dali::BaseHandle *)jarg1;
70541   if (!argp1) {
70542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70543     return 0;
70544   }
70545   arg1 = *argp1;
70546   {
70547     try {
70548       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
70549     } catch (std::out_of_range& e) {
70550       {
70551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70552       };
70553     } catch (std::exception& e) {
70554       {
70555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70556       };
70557     } catch (Dali::DaliException e) {
70558       {
70559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70560       };
70561     } catch (...) {
70562       {
70563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70564       };
70565     }
70566   }
70567
70568   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
70569   return jresult;
70570 }
70571
70572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
70573   int jresult ;
70574   int result;
70575
70576   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
70577   jresult = (int)result;
70578   return jresult;
70579 }
70580
70581
70582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
70583   int jresult ;
70584   int result;
70585
70586   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
70587   jresult = (int)result;
70588   return jresult;
70589 }
70590
70591
70592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
70593   int jresult ;
70594   int result;
70595
70596   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
70597   jresult = (int)result;
70598   return jresult;
70599 }
70600
70601
70602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
70603   void * jresult ;
70604   Dali::Toolkit::ImageView::Property *result = 0 ;
70605
70606   {
70607     try {
70608       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
70609     } catch (std::out_of_range& e) {
70610       {
70611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70612       };
70613     } catch (std::exception& e) {
70614       {
70615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70616       };
70617     } catch (Dali::DaliException e) {
70618       {
70619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70620       };
70621     } catch (...) {
70622       {
70623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70624       };
70625     }
70626   }
70627
70628   jresult = (void *)result;
70629   return jresult;
70630 }
70631
70632
70633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
70634   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
70635
70636   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
70637   {
70638     try {
70639       delete arg1;
70640     } catch (std::out_of_range& e) {
70641       {
70642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70643       };
70644     } catch (std::exception& e) {
70645       {
70646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70647       };
70648     } catch (Dali::DaliException e) {
70649       {
70650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70651       };
70652     } catch (...) {
70653       {
70654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70655       };
70656     }
70657   }
70658
70659 }
70660
70661
70662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
70663   void * jresult ;
70664   Dali::Toolkit::ImageView *result = 0 ;
70665
70666   {
70667     try {
70668       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
70669     } catch (std::out_of_range& e) {
70670       {
70671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70672       };
70673     } catch (std::exception& e) {
70674       {
70675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70676       };
70677     } catch (Dali::DaliException e) {
70678       {
70679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70680       };
70681     } catch (...) {
70682       {
70683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70684       };
70685     }
70686   }
70687
70688   jresult = (void *)result;
70689   return jresult;
70690 }
70691
70692
70693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
70694   void * jresult ;
70695   Dali::Toolkit::ImageView result;
70696
70697   {
70698     try {
70699       result = Dali::Toolkit::ImageView::New();
70700     } catch (std::out_of_range& e) {
70701       {
70702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70703       };
70704     } catch (std::exception& e) {
70705       {
70706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70707       };
70708     } catch (Dali::DaliException e) {
70709       {
70710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70711       };
70712     } catch (...) {
70713       {
70714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70715       };
70716     }
70717   }
70718
70719   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70720   return jresult;
70721 }
70722
70723
70724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
70725   void * jresult ;
70726   Dali::Image arg1 ;
70727   Dali::Image *argp1 ;
70728   Dali::Toolkit::ImageView result;
70729
70730   argp1 = (Dali::Image *)jarg1;
70731   if (!argp1) {
70732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70733     return 0;
70734   }
70735   arg1 = *argp1;
70736   {
70737     try {
70738       result = Dali::Toolkit::ImageView::New(arg1);
70739     } catch (std::out_of_range& e) {
70740       {
70741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70742       };
70743     } catch (std::exception& e) {
70744       {
70745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70746       };
70747     } catch (Dali::DaliException e) {
70748       {
70749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70750       };
70751     } catch (...) {
70752       {
70753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70754       };
70755     }
70756   }
70757
70758   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70759   return jresult;
70760 }
70761
70762
70763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
70764   void * jresult ;
70765   std::string *arg1 = 0 ;
70766   Dali::Toolkit::ImageView result;
70767
70768   if (!jarg1) {
70769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70770     return 0;
70771   }
70772   std::string arg1_str(jarg1);
70773   arg1 = &arg1_str;
70774   {
70775     try {
70776       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
70777     } catch (std::out_of_range& e) {
70778       {
70779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70780       };
70781     } catch (std::exception& e) {
70782       {
70783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70784       };
70785     } catch (Dali::DaliException e) {
70786       {
70787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70788       };
70789     } catch (...) {
70790       {
70791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70792       };
70793     }
70794   }
70795
70796   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70797
70798   //argout typemap for const std::string&
70799
70800   return jresult;
70801 }
70802
70803
70804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
70805   void * jresult ;
70806   std::string *arg1 = 0 ;
70807   Dali::ImageDimensions arg2 ;
70808   Dali::ImageDimensions *argp2 ;
70809   Dali::Toolkit::ImageView result;
70810
70811   if (!jarg1) {
70812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70813     return 0;
70814   }
70815   std::string arg1_str(jarg1);
70816   arg1 = &arg1_str;
70817   argp2 = (Dali::ImageDimensions *)jarg2;
70818   if (!argp2) {
70819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
70820     return 0;
70821   }
70822   arg2 = *argp2;
70823   {
70824     try {
70825       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
70826     } catch (std::out_of_range& e) {
70827       {
70828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70829       };
70830     } catch (std::exception& e) {
70831       {
70832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70833       };
70834     } catch (Dali::DaliException e) {
70835       {
70836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70837       };
70838     } catch (...) {
70839       {
70840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70841       };
70842     }
70843   }
70844
70845   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70846
70847   //argout typemap for const std::string&
70848
70849   return jresult;
70850 }
70851
70852
70853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
70854   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70855
70856   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70857   {
70858     try {
70859       delete arg1;
70860     } catch (std::out_of_range& e) {
70861       {
70862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70863       };
70864     } catch (std::exception& e) {
70865       {
70866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70867       };
70868     } catch (Dali::DaliException e) {
70869       {
70870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70871       };
70872     } catch (...) {
70873       {
70874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70875       };
70876     }
70877   }
70878
70879 }
70880
70881
70882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
70883   void * jresult ;
70884   Dali::Toolkit::ImageView *arg1 = 0 ;
70885   Dali::Toolkit::ImageView *result = 0 ;
70886
70887   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70888   if (!arg1) {
70889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
70890     return 0;
70891   }
70892   {
70893     try {
70894       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
70895     } catch (std::out_of_range& e) {
70896       {
70897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70898       };
70899     } catch (std::exception& e) {
70900       {
70901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70902       };
70903     } catch (Dali::DaliException e) {
70904       {
70905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70906       };
70907     } catch (...) {
70908       {
70909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70910       };
70911     }
70912   }
70913
70914   jresult = (void *)result;
70915   return jresult;
70916 }
70917
70918
70919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
70920   void * jresult ;
70921   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70922   Dali::Toolkit::ImageView *arg2 = 0 ;
70923   Dali::Toolkit::ImageView *result = 0 ;
70924
70925   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70926   arg2 = (Dali::Toolkit::ImageView *)jarg2;
70927   if (!arg2) {
70928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
70929     return 0;
70930   }
70931   {
70932     try {
70933       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
70934     } catch (std::out_of_range& e) {
70935       {
70936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70937       };
70938     } catch (std::exception& e) {
70939       {
70940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70941       };
70942     } catch (Dali::DaliException e) {
70943       {
70944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70945       };
70946     } catch (...) {
70947       {
70948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70949       };
70950     }
70951   }
70952
70953   jresult = (void *)result;
70954   return jresult;
70955 }
70956
70957
70958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
70959   void * jresult ;
70960   Dali::BaseHandle arg1 ;
70961   Dali::BaseHandle *argp1 ;
70962   Dali::Toolkit::ImageView result;
70963
70964   argp1 = (Dali::BaseHandle *)jarg1;
70965   if (!argp1) {
70966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70967     return 0;
70968   }
70969   arg1 = *argp1;
70970   {
70971     try {
70972       result = Dali::Toolkit::ImageView::DownCast(arg1);
70973     } catch (std::out_of_range& e) {
70974       {
70975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70976       };
70977     } catch (std::exception& e) {
70978       {
70979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70980       };
70981     } catch (Dali::DaliException e) {
70982       {
70983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70984       };
70985     } catch (...) {
70986       {
70987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70988       };
70989     }
70990   }
70991
70992   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70993   return jresult;
70994 }
70995
70996
70997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
70998   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70999   Dali::Image arg2 ;
71000   Dali::Image *argp2 ;
71001
71002   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71003   argp2 = (Dali::Image *)jarg2;
71004   if (!argp2) {
71005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71006     return ;
71007   }
71008   arg2 = *argp2;
71009   {
71010     try {
71011       (arg1)->SetImage(arg2);
71012     } catch (std::out_of_range& e) {
71013       {
71014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71015       };
71016     } catch (std::exception& e) {
71017       {
71018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71019       };
71020     } catch (Dali::DaliException e) {
71021       {
71022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71023       };
71024     } catch (...) {
71025       {
71026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71027       };
71028     }
71029   }
71030
71031 }
71032
71033
71034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
71035   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71036   std::string *arg2 = 0 ;
71037
71038   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71039   if (!jarg2) {
71040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71041     return ;
71042   }
71043   std::string arg2_str(jarg2);
71044   arg2 = &arg2_str;
71045   {
71046     try {
71047       (arg1)->SetImage((std::string const &)*arg2);
71048     } catch (std::out_of_range& e) {
71049       {
71050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71051       };
71052     } catch (std::exception& e) {
71053       {
71054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71055       };
71056     } catch (Dali::DaliException e) {
71057       {
71058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71059       };
71060     } catch (...) {
71061       {
71062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71063       };
71064     }
71065   }
71066
71067
71068   //argout typemap for const std::string&
71069
71070 }
71071
71072
71073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
71074   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71075   std::string *arg2 = 0 ;
71076   Dali::ImageDimensions arg3 ;
71077   Dali::ImageDimensions *argp3 ;
71078
71079   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71080   if (!jarg2) {
71081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71082     return ;
71083   }
71084   std::string arg2_str(jarg2);
71085   arg2 = &arg2_str;
71086   argp3 = (Dali::ImageDimensions *)jarg3;
71087   if (!argp3) {
71088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71089     return ;
71090   }
71091   arg3 = *argp3;
71092   {
71093     try {
71094       (arg1)->SetImage((std::string const &)*arg2,arg3);
71095     } catch (std::out_of_range& e) {
71096       {
71097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71098       };
71099     } catch (std::exception& e) {
71100       {
71101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71102       };
71103     } catch (Dali::DaliException e) {
71104       {
71105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71106       };
71107     } catch (...) {
71108       {
71109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71110       };
71111     }
71112   }
71113
71114
71115   //argout typemap for const std::string&
71116
71117 }
71118
71119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
71120   void * jresult ;
71121   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71122   Dali::Image result;
71123
71124   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71125   {
71126     try {
71127       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
71128     } catch (std::out_of_range& e) {
71129       {
71130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71131       };
71132     } catch (std::exception& e) {
71133       {
71134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71135       };
71136     } catch (Dali::DaliException e) {
71137       {
71138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71139       };
71140     } catch (...) {
71141       {
71142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71143       };
71144     }
71145   }
71146
71147   jresult = new Dali::Image((const Dali::Image &)result);
71148   return jresult;
71149 }
71150
71151
71152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
71153   int jresult ;
71154   int result;
71155
71156   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
71157   jresult = (int)result;
71158   return jresult;
71159 }
71160
71161
71162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
71163   int jresult ;
71164   int result;
71165
71166   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
71167   jresult = (int)result;
71168   return jresult;
71169 }
71170
71171
71172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
71173   int jresult ;
71174   int result;
71175
71176   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
71177   jresult = (int)result;
71178   return jresult;
71179 }
71180
71181
71182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
71183   int jresult ;
71184   int result;
71185
71186   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
71187   jresult = (int)result;
71188   return jresult;
71189 }
71190
71191
71192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
71193   int jresult ;
71194   int result;
71195
71196   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
71197   jresult = (int)result;
71198   return jresult;
71199 }
71200
71201
71202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
71203   int jresult ;
71204   int result;
71205
71206   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
71207   jresult = (int)result;
71208   return jresult;
71209 }
71210
71211
71212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
71213   int jresult ;
71214   int result;
71215
71216   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
71217   jresult = (int)result;
71218   return jresult;
71219 }
71220
71221
71222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
71223   int jresult ;
71224   int result;
71225
71226   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
71227   jresult = (int)result;
71228   return jresult;
71229 }
71230
71231
71232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
71233   void * jresult ;
71234   Dali::Toolkit::Model3dView::Property *result = 0 ;
71235
71236   {
71237     try {
71238       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
71239     } catch (std::out_of_range& e) {
71240       {
71241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71242       };
71243     } catch (std::exception& e) {
71244       {
71245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71246       };
71247     } catch (Dali::DaliException e) {
71248       {
71249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71250       };
71251     } catch (...) {
71252       {
71253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71254       };
71255     }
71256   }
71257
71258   jresult = (void *)result;
71259   return jresult;
71260 }
71261
71262
71263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
71264   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
71265
71266   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
71267   {
71268     try {
71269       delete arg1;
71270     } catch (std::out_of_range& e) {
71271       {
71272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71273       };
71274     } catch (std::exception& e) {
71275       {
71276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71277       };
71278     } catch (Dali::DaliException e) {
71279       {
71280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71281       };
71282     } catch (...) {
71283       {
71284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71285       };
71286     }
71287   }
71288
71289 }
71290
71291
71292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
71293   void * jresult ;
71294   Dali::Toolkit::Model3dView result;
71295
71296   {
71297     try {
71298       result = Dali::Toolkit::Model3dView::New();
71299     } catch (std::out_of_range& e) {
71300       {
71301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71302       };
71303     } catch (std::exception& e) {
71304       {
71305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71306       };
71307     } catch (Dali::DaliException e) {
71308       {
71309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71310       };
71311     } catch (...) {
71312       {
71313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71314       };
71315     }
71316   }
71317
71318   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71319   return jresult;
71320 }
71321
71322
71323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
71324   void * jresult ;
71325   std::string *arg1 = 0 ;
71326   std::string *arg2 = 0 ;
71327   std::string *arg3 = 0 ;
71328   Dali::Toolkit::Model3dView result;
71329
71330   if (!jarg1) {
71331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71332     return 0;
71333   }
71334   std::string arg1_str(jarg1);
71335   arg1 = &arg1_str;
71336   if (!jarg2) {
71337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71338     return 0;
71339   }
71340   std::string arg2_str(jarg2);
71341   arg2 = &arg2_str;
71342   if (!jarg3) {
71343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71344     return 0;
71345   }
71346   std::string arg3_str(jarg3);
71347   arg3 = &arg3_str;
71348   {
71349     try {
71350       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
71351     } catch (std::out_of_range& e) {
71352       {
71353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71354       };
71355     } catch (std::exception& e) {
71356       {
71357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71358       };
71359     } catch (Dali::DaliException e) {
71360       {
71361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71362       };
71363     } catch (...) {
71364       {
71365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71366       };
71367     }
71368   }
71369
71370   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71371
71372   //argout typemap for const std::string&
71373
71374
71375   //argout typemap for const std::string&
71376
71377
71378   //argout typemap for const std::string&
71379
71380   return jresult;
71381 }
71382
71383
71384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
71385   void * jresult ;
71386   Dali::Toolkit::Model3dView *result = 0 ;
71387
71388   {
71389     try {
71390       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
71391     } catch (std::out_of_range& e) {
71392       {
71393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71394       };
71395     } catch (std::exception& e) {
71396       {
71397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71398       };
71399     } catch (Dali::DaliException e) {
71400       {
71401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71402       };
71403     } catch (...) {
71404       {
71405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71406       };
71407     }
71408   }
71409
71410   jresult = (void *)result;
71411   return jresult;
71412 }
71413
71414
71415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
71416   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
71417
71418   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71419   {
71420     try {
71421       delete arg1;
71422     } catch (std::out_of_range& e) {
71423       {
71424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71425       };
71426     } catch (std::exception& e) {
71427       {
71428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71429       };
71430     } catch (Dali::DaliException e) {
71431       {
71432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71433       };
71434     } catch (...) {
71435       {
71436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71437       };
71438     }
71439   }
71440
71441 }
71442
71443
71444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
71445   void * jresult ;
71446   Dali::Toolkit::Model3dView *arg1 = 0 ;
71447   Dali::Toolkit::Model3dView *result = 0 ;
71448
71449   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71450   if (!arg1) {
71451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
71452     return 0;
71453   }
71454   {
71455     try {
71456       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
71457     } catch (std::out_of_range& e) {
71458       {
71459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71460       };
71461     } catch (std::exception& e) {
71462       {
71463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71464       };
71465     } catch (Dali::DaliException e) {
71466       {
71467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71468       };
71469     } catch (...) {
71470       {
71471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71472       };
71473     }
71474   }
71475
71476   jresult = (void *)result;
71477   return jresult;
71478 }
71479
71480
71481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
71482   void * jresult ;
71483   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
71484   Dali::Toolkit::Model3dView *arg2 = 0 ;
71485   Dali::Toolkit::Model3dView *result = 0 ;
71486
71487   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71488   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
71489   if (!arg2) {
71490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
71491     return 0;
71492   }
71493   {
71494     try {
71495       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
71496     } catch (std::out_of_range& e) {
71497       {
71498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71499       };
71500     } catch (std::exception& e) {
71501       {
71502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71503       };
71504     } catch (Dali::DaliException e) {
71505       {
71506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71507       };
71508     } catch (...) {
71509       {
71510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71511       };
71512     }
71513   }
71514
71515   jresult = (void *)result;
71516   return jresult;
71517 }
71518
71519
71520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
71521   void * jresult ;
71522   Dali::BaseHandle arg1 ;
71523   Dali::BaseHandle *argp1 ;
71524   Dali::Toolkit::Model3dView result;
71525
71526   argp1 = (Dali::BaseHandle *)jarg1;
71527   if (!argp1) {
71528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71529     return 0;
71530   }
71531   arg1 = *argp1;
71532   {
71533     try {
71534       result = Dali::Toolkit::Model3dView::DownCast(arg1);
71535     } catch (std::out_of_range& e) {
71536       {
71537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71538       };
71539     } catch (std::exception& e) {
71540       {
71541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71542       };
71543     } catch (Dali::DaliException e) {
71544       {
71545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71546       };
71547     } catch (...) {
71548       {
71549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71550       };
71551     }
71552   }
71553
71554   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71555   return jresult;
71556 }
71557
71558
71559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
71560   int jresult ;
71561   int result;
71562
71563   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
71564   jresult = (int)result;
71565   return jresult;
71566 }
71567
71568
71569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
71570   int jresult ;
71571   int result;
71572
71573   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
71574   jresult = (int)result;
71575   return jresult;
71576 }
71577
71578
71579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
71580   int jresult ;
71581   int result;
71582
71583   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
71584   jresult = (int)result;
71585   return jresult;
71586 }
71587
71588
71589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
71590   int jresult ;
71591   int result;
71592
71593   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
71594   jresult = (int)result;
71595   return jresult;
71596 }
71597
71598
71599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
71600   int jresult ;
71601   int result;
71602
71603   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
71604   jresult = (int)result;
71605   return jresult;
71606 }
71607
71608
71609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
71610   int jresult ;
71611   int result;
71612
71613   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
71614   jresult = (int)result;
71615   return jresult;
71616 }
71617
71618
71619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
71620   int jresult ;
71621   int result;
71622
71623   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
71624   jresult = (int)result;
71625   return jresult;
71626 }
71627
71628
71629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
71630   int jresult ;
71631   int result;
71632
71633   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
71634   jresult = (int)result;
71635   return jresult;
71636 }
71637
71638
71639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
71640   int jresult ;
71641   int result;
71642
71643   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
71644   jresult = (int)result;
71645   return jresult;
71646 }
71647
71648
71649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
71650   void * jresult ;
71651   Dali::Toolkit::ScrollBar::Property *result = 0 ;
71652
71653   {
71654     try {
71655       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
71656     } catch (std::out_of_range& e) {
71657       {
71658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71659       };
71660     } catch (std::exception& e) {
71661       {
71662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71663       };
71664     } catch (Dali::DaliException e) {
71665       {
71666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71667       };
71668     } catch (...) {
71669       {
71670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71671       };
71672     }
71673   }
71674
71675   jresult = (void *)result;
71676   return jresult;
71677 }
71678
71679
71680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
71681   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
71682
71683   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
71684   {
71685     try {
71686       delete arg1;
71687     } catch (std::out_of_range& e) {
71688       {
71689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71690       };
71691     } catch (std::exception& e) {
71692       {
71693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71694       };
71695     } catch (Dali::DaliException e) {
71696       {
71697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71698       };
71699     } catch (...) {
71700       {
71701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71702       };
71703     }
71704   }
71705
71706 }
71707
71708
71709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
71710   void * jresult ;
71711   Dali::Toolkit::ScrollBar *result = 0 ;
71712
71713   {
71714     try {
71715       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
71716     } catch (std::out_of_range& e) {
71717       {
71718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71719       };
71720     } catch (std::exception& e) {
71721       {
71722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71723       };
71724     } catch (Dali::DaliException e) {
71725       {
71726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71727       };
71728     } catch (...) {
71729       {
71730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71731       };
71732     }
71733   }
71734
71735   jresult = (void *)result;
71736   return jresult;
71737 }
71738
71739
71740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
71741   void * jresult ;
71742   Dali::Toolkit::ScrollBar *arg1 = 0 ;
71743   Dali::Toolkit::ScrollBar *result = 0 ;
71744
71745   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71746   if (!arg1) {
71747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
71748     return 0;
71749   }
71750   {
71751     try {
71752       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
71753     } catch (std::out_of_range& e) {
71754       {
71755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71756       };
71757     } catch (std::exception& e) {
71758       {
71759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71760       };
71761     } catch (Dali::DaliException e) {
71762       {
71763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71764       };
71765     } catch (...) {
71766       {
71767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71768       };
71769     }
71770   }
71771
71772   jresult = (void *)result;
71773   return jresult;
71774 }
71775
71776
71777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
71778   void * jresult ;
71779   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71780   Dali::Toolkit::ScrollBar *arg2 = 0 ;
71781   Dali::Toolkit::ScrollBar *result = 0 ;
71782
71783   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71784   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
71785   if (!arg2) {
71786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
71787     return 0;
71788   }
71789   {
71790     try {
71791       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
71792     } catch (std::out_of_range& e) {
71793       {
71794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71795       };
71796     } catch (std::exception& e) {
71797       {
71798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71799       };
71800     } catch (Dali::DaliException e) {
71801       {
71802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71803       };
71804     } catch (...) {
71805       {
71806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71807       };
71808     }
71809   }
71810
71811   jresult = (void *)result;
71812   return jresult;
71813 }
71814
71815
71816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
71817   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71818
71819   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71820   {
71821     try {
71822       delete arg1;
71823     } catch (std::out_of_range& e) {
71824       {
71825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71826       };
71827     } catch (std::exception& e) {
71828       {
71829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71830       };
71831     } catch (Dali::DaliException e) {
71832       {
71833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71834       };
71835     } catch (...) {
71836       {
71837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71838       };
71839     }
71840   }
71841
71842 }
71843
71844
71845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
71846   void * jresult ;
71847   Dali::Toolkit::ScrollBar::Direction arg1 ;
71848   Dali::Toolkit::ScrollBar result;
71849
71850   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
71851   {
71852     try {
71853       result = Dali::Toolkit::ScrollBar::New(arg1);
71854     } catch (std::out_of_range& e) {
71855       {
71856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71857       };
71858     } catch (std::exception& e) {
71859       {
71860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71861       };
71862     } catch (Dali::DaliException e) {
71863       {
71864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71865       };
71866     } catch (...) {
71867       {
71868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71869       };
71870     }
71871   }
71872
71873   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71874   return jresult;
71875 }
71876
71877
71878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
71879   void * jresult ;
71880   Dali::Toolkit::ScrollBar result;
71881
71882   {
71883     try {
71884       result = Dali::Toolkit::ScrollBar::New();
71885     } catch (std::out_of_range& e) {
71886       {
71887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71888       };
71889     } catch (std::exception& e) {
71890       {
71891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71892       };
71893     } catch (Dali::DaliException e) {
71894       {
71895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71896       };
71897     } catch (...) {
71898       {
71899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71900       };
71901     }
71902   }
71903
71904   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71905   return jresult;
71906 }
71907
71908
71909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
71910   void * jresult ;
71911   Dali::BaseHandle arg1 ;
71912   Dali::BaseHandle *argp1 ;
71913   Dali::Toolkit::ScrollBar result;
71914
71915   argp1 = (Dali::BaseHandle *)jarg1;
71916   if (!argp1) {
71917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71918     return 0;
71919   }
71920   arg1 = *argp1;
71921   {
71922     try {
71923       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
71924     } catch (std::out_of_range& e) {
71925       {
71926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71927       };
71928     } catch (std::exception& e) {
71929       {
71930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71931       };
71932     } catch (Dali::DaliException e) {
71933       {
71934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71935       };
71936     } catch (...) {
71937       {
71938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71939       };
71940     }
71941   }
71942
71943   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71944   return jresult;
71945 }
71946
71947
71948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
71949   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71950   Dali::Handle arg2 ;
71951   Dali::Property::Index arg3 ;
71952   Dali::Property::Index arg4 ;
71953   Dali::Property::Index arg5 ;
71954   Dali::Property::Index arg6 ;
71955   Dali::Handle *argp2 ;
71956
71957   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71958   argp2 = (Dali::Handle *)jarg2;
71959   if (!argp2) {
71960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
71961     return ;
71962   }
71963   arg2 = *argp2;
71964   arg3 = (Dali::Property::Index)jarg3;
71965   arg4 = (Dali::Property::Index)jarg4;
71966   arg5 = (Dali::Property::Index)jarg5;
71967   arg6 = (Dali::Property::Index)jarg6;
71968   {
71969     try {
71970       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
71971     } catch (std::out_of_range& e) {
71972       {
71973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71974       };
71975     } catch (std::exception& e) {
71976       {
71977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71978       };
71979     } catch (Dali::DaliException e) {
71980       {
71981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71982       };
71983     } catch (...) {
71984       {
71985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71986       };
71987     }
71988   }
71989
71990 }
71991
71992
71993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
71994   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71995   Dali::Actor arg2 ;
71996   Dali::Actor *argp2 ;
71997
71998   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71999   argp2 = (Dali::Actor *)jarg2;
72000   if (!argp2) {
72001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72002     return ;
72003   }
72004   arg2 = *argp2;
72005   {
72006     try {
72007       (arg1)->SetScrollIndicator(arg2);
72008     } catch (std::out_of_range& e) {
72009       {
72010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72011       };
72012     } catch (std::exception& e) {
72013       {
72014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72015       };
72016     } catch (Dali::DaliException e) {
72017       {
72018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72019       };
72020     } catch (...) {
72021       {
72022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72023       };
72024     }
72025   }
72026
72027 }
72028
72029
72030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
72031   void * jresult ;
72032   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72033   Dali::Actor result;
72034
72035   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72036   {
72037     try {
72038       result = (arg1)->GetScrollIndicator();
72039     } catch (std::out_of_range& e) {
72040       {
72041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72042       };
72043     } catch (std::exception& e) {
72044       {
72045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72046       };
72047     } catch (Dali::DaliException e) {
72048       {
72049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72050       };
72051     } catch (...) {
72052       {
72053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72054       };
72055     }
72056   }
72057
72058   jresult = new Dali::Actor((const Dali::Actor &)result);
72059   return jresult;
72060 }
72061
72062
72063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
72064   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72065   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
72066
72067   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72068   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
72069   if (!arg2) {
72070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
72071     return ;
72072   }
72073   {
72074     try {
72075       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
72076     } catch (std::out_of_range& e) {
72077       {
72078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72079       };
72080     } catch (std::exception& e) {
72081       {
72082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72083       };
72084     } catch (Dali::DaliException e) {
72085       {
72086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72087       };
72088     } catch (...) {
72089       {
72090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72091       };
72092     }
72093   }
72094
72095 }
72096
72097
72098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
72099   void * jresult ;
72100   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72101
72102   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72103   {
72104     try {
72105       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()));
72106     } catch (std::out_of_range& e) {
72107       {
72108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72109       };
72110     } catch (std::exception& e) {
72111       {
72112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72113       };
72114     } catch (...) {
72115       {
72116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72117       };
72118     }
72119   }
72120   return jresult;
72121 }
72122
72123
72124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
72125   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72126   Dali::Toolkit::ScrollBar::Direction arg2 ;
72127
72128   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72129   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
72130   {
72131     try {
72132       (arg1)->SetScrollDirection(arg2);
72133     } catch (std::out_of_range& e) {
72134       {
72135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72136       };
72137     } catch (std::exception& e) {
72138       {
72139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72140       };
72141     } catch (Dali::DaliException e) {
72142       {
72143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72144       };
72145     } catch (...) {
72146       {
72147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72148       };
72149     }
72150   }
72151
72152 }
72153
72154
72155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
72156   int jresult ;
72157   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72158   Dali::Toolkit::ScrollBar::Direction result;
72159
72160   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72161   {
72162     try {
72163       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
72164     } catch (std::out_of_range& e) {
72165       {
72166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72167       };
72168     } catch (std::exception& e) {
72169       {
72170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72171       };
72172     } catch (Dali::DaliException e) {
72173       {
72174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72175       };
72176     } catch (...) {
72177       {
72178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72179       };
72180     }
72181   }
72182
72183   jresult = (int)result;
72184   return jresult;
72185 }
72186
72187
72188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
72189   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72190   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
72191
72192   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72193   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
72194   {
72195     try {
72196       (arg1)->SetIndicatorHeightPolicy(arg2);
72197     } catch (std::out_of_range& e) {
72198       {
72199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72200       };
72201     } catch (std::exception& e) {
72202       {
72203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72204       };
72205     } catch (Dali::DaliException e) {
72206       {
72207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72208       };
72209     } catch (...) {
72210       {
72211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72212       };
72213     }
72214   }
72215
72216 }
72217
72218
72219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
72220   int jresult ;
72221   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72222   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
72223
72224   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72225   {
72226     try {
72227       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
72228     } catch (std::out_of_range& e) {
72229       {
72230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72231       };
72232     } catch (std::exception& e) {
72233       {
72234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72235       };
72236     } catch (Dali::DaliException e) {
72237       {
72238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72239       };
72240     } catch (...) {
72241       {
72242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72243       };
72244     }
72245   }
72246
72247   jresult = (int)result;
72248   return jresult;
72249 }
72250
72251
72252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
72253   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72254   float arg2 ;
72255
72256   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72257   arg2 = (float)jarg2;
72258   {
72259     try {
72260       (arg1)->SetIndicatorFixedHeight(arg2);
72261     } catch (std::out_of_range& e) {
72262       {
72263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72264       };
72265     } catch (std::exception& e) {
72266       {
72267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72268       };
72269     } catch (Dali::DaliException e) {
72270       {
72271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72272       };
72273     } catch (...) {
72274       {
72275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72276       };
72277     }
72278   }
72279
72280 }
72281
72282
72283 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
72284   float jresult ;
72285   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72286   float result;
72287
72288   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72289   {
72290     try {
72291       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
72292     } catch (std::out_of_range& e) {
72293       {
72294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72295       };
72296     } catch (std::exception& e) {
72297       {
72298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72299       };
72300     } catch (Dali::DaliException e) {
72301       {
72302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72303       };
72304     } catch (...) {
72305       {
72306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72307       };
72308     }
72309   }
72310
72311   jresult = result;
72312   return jresult;
72313 }
72314
72315
72316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
72317   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72318   float arg2 ;
72319
72320   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72321   arg2 = (float)jarg2;
72322   {
72323     try {
72324       (arg1)->SetIndicatorShowDuration(arg2);
72325     } catch (std::out_of_range& e) {
72326       {
72327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72328       };
72329     } catch (std::exception& e) {
72330       {
72331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72332       };
72333     } catch (Dali::DaliException e) {
72334       {
72335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72336       };
72337     } catch (...) {
72338       {
72339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72340       };
72341     }
72342   }
72343
72344 }
72345
72346
72347 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
72348   float jresult ;
72349   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72350   float result;
72351
72352   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72353   {
72354     try {
72355       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
72356     } catch (std::out_of_range& e) {
72357       {
72358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72359       };
72360     } catch (std::exception& e) {
72361       {
72362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72363       };
72364     } catch (Dali::DaliException e) {
72365       {
72366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72367       };
72368     } catch (...) {
72369       {
72370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72371       };
72372     }
72373   }
72374
72375   jresult = result;
72376   return jresult;
72377 }
72378
72379
72380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
72381   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72382   float arg2 ;
72383
72384   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72385   arg2 = (float)jarg2;
72386   {
72387     try {
72388       (arg1)->SetIndicatorHideDuration(arg2);
72389     } catch (std::out_of_range& e) {
72390       {
72391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72392       };
72393     } catch (std::exception& e) {
72394       {
72395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72396       };
72397     } catch (Dali::DaliException e) {
72398       {
72399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72400       };
72401     } catch (...) {
72402       {
72403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72404       };
72405     }
72406   }
72407
72408 }
72409
72410
72411 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
72412   float jresult ;
72413   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72414   float result;
72415
72416   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72417   {
72418     try {
72419       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
72420     } catch (std::out_of_range& e) {
72421       {
72422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72423       };
72424     } catch (std::exception& e) {
72425       {
72426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72427       };
72428     } catch (Dali::DaliException e) {
72429       {
72430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72431       };
72432     } catch (...) {
72433       {
72434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72435       };
72436     }
72437   }
72438
72439   jresult = result;
72440   return jresult;
72441 }
72442
72443
72444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
72445   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72446
72447   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72448   {
72449     try {
72450       (arg1)->ShowIndicator();
72451     } catch (std::out_of_range& e) {
72452       {
72453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72454       };
72455     } catch (std::exception& e) {
72456       {
72457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72458       };
72459     } catch (Dali::DaliException e) {
72460       {
72461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72462       };
72463     } catch (...) {
72464       {
72465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72466       };
72467     }
72468   }
72469
72470 }
72471
72472
72473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
72474   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72475
72476   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72477   {
72478     try {
72479       (arg1)->HideIndicator();
72480     } catch (std::out_of_range& e) {
72481       {
72482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72483       };
72484     } catch (std::exception& e) {
72485       {
72486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72487       };
72488     } catch (Dali::DaliException e) {
72489       {
72490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72491       };
72492     } catch (...) {
72493       {
72494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72495       };
72496     }
72497   }
72498
72499 }
72500
72501
72502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
72503   void * jresult ;
72504   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72505   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
72506
72507   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72508   {
72509     try {
72510       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
72511     } catch (std::out_of_range& e) {
72512       {
72513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72514       };
72515     } catch (std::exception& e) {
72516       {
72517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72518       };
72519     } catch (Dali::DaliException e) {
72520       {
72521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72522       };
72523     } catch (...) {
72524       {
72525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72526       };
72527     }
72528   }
72529
72530   jresult = (void *)result;
72531   return jresult;
72532 }
72533
72534
72535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
72536   void * jresult ;
72537   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72538   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
72539
72540   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72541   {
72542     try {
72543       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
72544     } catch (std::out_of_range& e) {
72545       {
72546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72547       };
72548     } catch (std::exception& e) {
72549       {
72550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72551       };
72552     } catch (Dali::DaliException e) {
72553       {
72554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72555       };
72556     } catch (...) {
72557       {
72558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72559       };
72560     }
72561   }
72562
72563   jresult = (void *)result;
72564   return jresult;
72565 }
72566
72567
72568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
72569   int jresult ;
72570   int result;
72571
72572   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
72573   jresult = (int)result;
72574   return jresult;
72575 }
72576
72577
72578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
72579   int jresult ;
72580   int result;
72581
72582   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
72583   jresult = (int)result;
72584   return jresult;
72585 }
72586
72587
72588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
72589   int jresult ;
72590   int result;
72591
72592   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
72593   jresult = (int)result;
72594   return jresult;
72595 }
72596
72597
72598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
72599   int jresult ;
72600   int result;
72601
72602   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
72603   jresult = (int)result;
72604   return jresult;
72605 }
72606
72607
72608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
72609   int jresult ;
72610   int result;
72611
72612   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
72613   jresult = (int)result;
72614   return jresult;
72615 }
72616
72617
72618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
72619   int jresult ;
72620   int result;
72621
72622   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
72623   jresult = (int)result;
72624   return jresult;
72625 }
72626
72627
72628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
72629   int jresult ;
72630   int result;
72631
72632   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
72633   jresult = (int)result;
72634   return jresult;
72635 }
72636
72637
72638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
72639   int jresult ;
72640   int result;
72641
72642   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
72643   jresult = (int)result;
72644   return jresult;
72645 }
72646
72647
72648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
72649   int jresult ;
72650   int result;
72651
72652   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
72653   jresult = (int)result;
72654   return jresult;
72655 }
72656
72657
72658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
72659   int jresult ;
72660   int result;
72661
72662   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
72663   jresult = (int)result;
72664   return jresult;
72665 }
72666
72667
72668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
72669   int jresult ;
72670   int result;
72671
72672   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
72673   jresult = (int)result;
72674   return jresult;
72675 }
72676
72677
72678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
72679   int jresult ;
72680   int result;
72681
72682   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
72683   jresult = (int)result;
72684   return jresult;
72685 }
72686
72687
72688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
72689   int jresult ;
72690   int result;
72691
72692   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
72693   jresult = (int)result;
72694   return jresult;
72695 }
72696
72697
72698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
72699   int jresult ;
72700   int result;
72701
72702   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
72703   jresult = (int)result;
72704   return jresult;
72705 }
72706
72707
72708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
72709   void * jresult ;
72710   Dali::Toolkit::Scrollable::Property *result = 0 ;
72711
72712   {
72713     try {
72714       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
72715     } catch (std::out_of_range& e) {
72716       {
72717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72718       };
72719     } catch (std::exception& e) {
72720       {
72721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72722       };
72723     } catch (Dali::DaliException e) {
72724       {
72725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72726       };
72727     } catch (...) {
72728       {
72729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72730       };
72731     }
72732   }
72733
72734   jresult = (void *)result;
72735   return jresult;
72736 }
72737
72738
72739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
72740   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
72741
72742   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
72743   {
72744     try {
72745       delete arg1;
72746     } catch (std::out_of_range& e) {
72747       {
72748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72749       };
72750     } catch (std::exception& e) {
72751       {
72752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72753       };
72754     } catch (Dali::DaliException e) {
72755       {
72756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72757       };
72758     } catch (...) {
72759       {
72760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72761       };
72762     }
72763   }
72764
72765 }
72766
72767
72768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
72769   void * jresult ;
72770   Dali::Toolkit::Scrollable *result = 0 ;
72771
72772   {
72773     try {
72774       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
72775     } catch (std::out_of_range& e) {
72776       {
72777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72778       };
72779     } catch (std::exception& e) {
72780       {
72781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72782       };
72783     } catch (Dali::DaliException e) {
72784       {
72785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72786       };
72787     } catch (...) {
72788       {
72789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72790       };
72791     }
72792   }
72793
72794   jresult = (void *)result;
72795   return jresult;
72796 }
72797
72798
72799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
72800   void * jresult ;
72801   Dali::Toolkit::Scrollable *arg1 = 0 ;
72802   Dali::Toolkit::Scrollable *result = 0 ;
72803
72804   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72805   if (!arg1) {
72806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
72807     return 0;
72808   }
72809   {
72810     try {
72811       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
72812     } catch (std::out_of_range& e) {
72813       {
72814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72815       };
72816     } catch (std::exception& e) {
72817       {
72818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72819       };
72820     } catch (Dali::DaliException e) {
72821       {
72822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72823       };
72824     } catch (...) {
72825       {
72826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72827       };
72828     }
72829   }
72830
72831   jresult = (void *)result;
72832   return jresult;
72833 }
72834
72835
72836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
72837   void * jresult ;
72838   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72839   Dali::Toolkit::Scrollable *arg2 = 0 ;
72840   Dali::Toolkit::Scrollable *result = 0 ;
72841
72842   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72843   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
72844   if (!arg2) {
72845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
72846     return 0;
72847   }
72848   {
72849     try {
72850       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
72851     } catch (std::out_of_range& e) {
72852       {
72853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72854       };
72855     } catch (std::exception& e) {
72856       {
72857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72858       };
72859     } catch (Dali::DaliException e) {
72860       {
72861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72862       };
72863     } catch (...) {
72864       {
72865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72866       };
72867     }
72868   }
72869
72870   jresult = (void *)result;
72871   return jresult;
72872 }
72873
72874
72875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
72876   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72877
72878   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72879   {
72880     try {
72881       delete arg1;
72882     } catch (std::out_of_range& e) {
72883       {
72884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72885       };
72886     } catch (std::exception& e) {
72887       {
72888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72889       };
72890     } catch (Dali::DaliException e) {
72891       {
72892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72893       };
72894     } catch (...) {
72895       {
72896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72897       };
72898     }
72899   }
72900
72901 }
72902
72903
72904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
72905   void * jresult ;
72906   Dali::BaseHandle arg1 ;
72907   Dali::BaseHandle *argp1 ;
72908   Dali::Toolkit::Scrollable result;
72909
72910   argp1 = (Dali::BaseHandle *)jarg1;
72911   if (!argp1) {
72912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72913     return 0;
72914   }
72915   arg1 = *argp1;
72916   {
72917     try {
72918       result = Dali::Toolkit::Scrollable::DownCast(arg1);
72919     } catch (std::out_of_range& e) {
72920       {
72921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72922       };
72923     } catch (std::exception& e) {
72924       {
72925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72926       };
72927     } catch (Dali::DaliException e) {
72928       {
72929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72930       };
72931     } catch (...) {
72932       {
72933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72934       };
72935     }
72936   }
72937
72938   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
72939   return jresult;
72940 }
72941
72942
72943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
72944   unsigned int jresult ;
72945   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72946   bool result;
72947
72948   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72949   {
72950     try {
72951       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
72952     } catch (std::out_of_range& e) {
72953       {
72954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72955       };
72956     } catch (std::exception& e) {
72957       {
72958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72959       };
72960     } catch (Dali::DaliException e) {
72961       {
72962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72963       };
72964     } catch (...) {
72965       {
72966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72967       };
72968     }
72969   }
72970
72971   jresult = result;
72972   return jresult;
72973 }
72974
72975
72976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
72977   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72978   bool arg2 ;
72979
72980   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72981   arg2 = jarg2 ? true : false;
72982   {
72983     try {
72984       (arg1)->SetOvershootEnabled(arg2);
72985     } catch (std::out_of_range& e) {
72986       {
72987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72988       };
72989     } catch (std::exception& e) {
72990       {
72991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72992       };
72993     } catch (Dali::DaliException e) {
72994       {
72995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72996       };
72997     } catch (...) {
72998       {
72999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73000       };
73001     }
73002   }
73003
73004 }
73005
73006
73007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
73008   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73009   Dali::Vector4 *arg2 = 0 ;
73010
73011   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73012   arg2 = (Dali::Vector4 *)jarg2;
73013   if (!arg2) {
73014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
73015     return ;
73016   }
73017   {
73018     try {
73019       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
73020     } catch (std::out_of_range& e) {
73021       {
73022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73023       };
73024     } catch (std::exception& e) {
73025       {
73026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73027       };
73028     } catch (Dali::DaliException e) {
73029       {
73030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73031       };
73032     } catch (...) {
73033       {
73034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73035       };
73036     }
73037   }
73038
73039 }
73040
73041
73042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
73043   void * jresult ;
73044   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73045   Dali::Vector4 result;
73046
73047   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73048   {
73049     try {
73050       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
73051     } catch (std::out_of_range& e) {
73052       {
73053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73054       };
73055     } catch (std::exception& e) {
73056       {
73057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73058       };
73059     } catch (Dali::DaliException e) {
73060       {
73061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73062       };
73063     } catch (...) {
73064       {
73065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73066       };
73067     }
73068   }
73069
73070   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
73071   return jresult;
73072 }
73073
73074
73075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
73076   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73077   float arg2 ;
73078
73079   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73080   arg2 = (float)jarg2;
73081   {
73082     try {
73083       (arg1)->SetOvershootAnimationSpeed(arg2);
73084     } catch (std::out_of_range& e) {
73085       {
73086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73087       };
73088     } catch (std::exception& e) {
73089       {
73090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73091       };
73092     } catch (Dali::DaliException e) {
73093       {
73094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73095       };
73096     } catch (...) {
73097       {
73098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73099       };
73100     }
73101   }
73102
73103 }
73104
73105
73106 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
73107   float jresult ;
73108   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73109   float result;
73110
73111   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73112   {
73113     try {
73114       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
73115     } catch (std::out_of_range& e) {
73116       {
73117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73118       };
73119     } catch (std::exception& e) {
73120       {
73121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73122       };
73123     } catch (Dali::DaliException e) {
73124       {
73125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73126       };
73127     } catch (...) {
73128       {
73129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73130       };
73131     }
73132   }
73133
73134   jresult = result;
73135   return jresult;
73136 }
73137
73138
73139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
73140   void * jresult ;
73141   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73142   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
73143
73144   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73145   {
73146     try {
73147       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
73148     } catch (std::out_of_range& e) {
73149       {
73150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73151       };
73152     } catch (std::exception& e) {
73153       {
73154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73155       };
73156     } catch (Dali::DaliException e) {
73157       {
73158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73159       };
73160     } catch (...) {
73161       {
73162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73163       };
73164     }
73165   }
73166
73167   jresult = (void *)result;
73168   return jresult;
73169 }
73170
73171
73172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
73173   void * jresult ;
73174   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73175   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
73176
73177   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73178   {
73179     try {
73180       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
73181     } catch (std::out_of_range& e) {
73182       {
73183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73184       };
73185     } catch (std::exception& e) {
73186       {
73187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73188       };
73189     } catch (Dali::DaliException e) {
73190       {
73191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73192       };
73193     } catch (...) {
73194       {
73195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73196       };
73197     }
73198   }
73199
73200   jresult = (void *)result;
73201   return jresult;
73202 }
73203
73204
73205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
73206   void * jresult ;
73207   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73208   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
73209
73210   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73211   {
73212     try {
73213       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
73214     } catch (std::out_of_range& e) {
73215       {
73216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73217       };
73218     } catch (std::exception& e) {
73219       {
73220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73221       };
73222     } catch (Dali::DaliException e) {
73223       {
73224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73225       };
73226     } catch (...) {
73227       {
73228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73229       };
73230     }
73231   }
73232
73233   jresult = (void *)result;
73234   return jresult;
73235 }
73236
73237
73238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
73239   unsigned int jresult ;
73240   Dali::Toolkit::ControlOrientation::Type arg1 ;
73241   bool result;
73242
73243   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
73244   {
73245     try {
73246       result = (bool)Dali::Toolkit::IsVertical(arg1);
73247     } catch (std::out_of_range& e) {
73248       {
73249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73250       };
73251     } catch (std::exception& e) {
73252       {
73253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73254       };
73255     } catch (Dali::DaliException e) {
73256       {
73257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73258       };
73259     } catch (...) {
73260       {
73261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73262       };
73263     }
73264   }
73265
73266   jresult = result;
73267   return jresult;
73268 }
73269
73270
73271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
73272   unsigned int jresult ;
73273   Dali::Toolkit::ControlOrientation::Type arg1 ;
73274   bool result;
73275
73276   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
73277   {
73278     try {
73279       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
73280     } catch (std::out_of_range& e) {
73281       {
73282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73283       };
73284     } catch (std::exception& e) {
73285       {
73286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73287       };
73288     } catch (Dali::DaliException e) {
73289       {
73290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73291       };
73292     } catch (...) {
73293       {
73294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73295       };
73296     }
73297   }
73298
73299   jresult = result;
73300   return jresult;
73301 }
73302
73303
73304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
73305   void * jresult ;
73306   unsigned int arg1 ;
73307   unsigned int arg2 ;
73308   Dali::Toolkit::ItemRange *result = 0 ;
73309
73310   arg1 = (unsigned int)jarg1;
73311   arg2 = (unsigned int)jarg2;
73312   {
73313     try {
73314       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
73315     } catch (std::out_of_range& e) {
73316       {
73317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73318       };
73319     } catch (std::exception& e) {
73320       {
73321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73322       };
73323     } catch (Dali::DaliException e) {
73324       {
73325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73326       };
73327     } catch (...) {
73328       {
73329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73330       };
73331     }
73332   }
73333
73334   jresult = (void *)result;
73335   return jresult;
73336 }
73337
73338
73339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
73340   void * jresult ;
73341   Dali::Toolkit::ItemRange *arg1 = 0 ;
73342   Dali::Toolkit::ItemRange *result = 0 ;
73343
73344   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73345   if (!arg1) {
73346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73347     return 0;
73348   }
73349   {
73350     try {
73351       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
73352     } catch (std::out_of_range& e) {
73353       {
73354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73355       };
73356     } catch (std::exception& e) {
73357       {
73358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73359       };
73360     } catch (Dali::DaliException e) {
73361       {
73362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73363       };
73364     } catch (...) {
73365       {
73366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73367       };
73368     }
73369   }
73370
73371   jresult = (void *)result;
73372   return jresult;
73373 }
73374
73375
73376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
73377   void * jresult ;
73378   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73379   Dali::Toolkit::ItemRange *arg2 = 0 ;
73380   Dali::Toolkit::ItemRange *result = 0 ;
73381
73382   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73383   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
73384   if (!arg2) {
73385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73386     return 0;
73387   }
73388   {
73389     try {
73390       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
73391     } catch (std::out_of_range& e) {
73392       {
73393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73394       };
73395     } catch (std::exception& e) {
73396       {
73397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73398       };
73399     } catch (Dali::DaliException e) {
73400       {
73401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73402       };
73403     } catch (...) {
73404       {
73405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73406       };
73407     }
73408   }
73409
73410   jresult = (void *)result;
73411   return jresult;
73412 }
73413
73414
73415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
73416   unsigned int jresult ;
73417   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73418   unsigned int arg2 ;
73419   bool result;
73420
73421   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73422   arg2 = (unsigned int)jarg2;
73423   {
73424     try {
73425       result = (bool)(arg1)->Within(arg2);
73426     } catch (std::out_of_range& e) {
73427       {
73428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73429       };
73430     } catch (std::exception& e) {
73431       {
73432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73433       };
73434     } catch (Dali::DaliException e) {
73435       {
73436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73437       };
73438     } catch (...) {
73439       {
73440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73441       };
73442     }
73443   }
73444
73445   jresult = result;
73446   return jresult;
73447 }
73448
73449
73450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
73451   void * jresult ;
73452   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73453   Dali::Toolkit::ItemRange *arg2 = 0 ;
73454   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
73455
73456   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73457   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
73458   if (!arg2) {
73459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73460     return 0;
73461   }
73462   {
73463     try {
73464       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
73465     } catch (std::out_of_range& e) {
73466       {
73467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73468       };
73469     } catch (std::exception& e) {
73470       {
73471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73472       };
73473     } catch (Dali::DaliException e) {
73474       {
73475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73476       };
73477     } catch (...) {
73478       {
73479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73480       };
73481     }
73482   }
73483
73484   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
73485   return jresult;
73486 }
73487
73488
73489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
73490   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73491   unsigned int arg2 ;
73492
73493   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73494   arg2 = (unsigned int)jarg2;
73495   if (arg1) (arg1)->begin = arg2;
73496 }
73497
73498
73499 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
73500   unsigned int jresult ;
73501   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73502   unsigned int result;
73503
73504   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73505   result = (unsigned int) ((arg1)->begin);
73506   jresult = result;
73507   return jresult;
73508 }
73509
73510
73511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
73512   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73513   unsigned int arg2 ;
73514
73515   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73516   arg2 = (unsigned int)jarg2;
73517   if (arg1) (arg1)->end = arg2;
73518 }
73519
73520
73521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
73522   unsigned int jresult ;
73523   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73524   unsigned int result;
73525
73526   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73527   result = (unsigned int) ((arg1)->end);
73528   jresult = result;
73529   return jresult;
73530 }
73531
73532
73533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
73534   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73535
73536   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73537   {
73538     try {
73539       delete arg1;
73540     } catch (std::out_of_range& e) {
73541       {
73542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73543       };
73544     } catch (std::exception& e) {
73545       {
73546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73547       };
73548     } catch (Dali::DaliException e) {
73549       {
73550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73551       };
73552     } catch (...) {
73553       {
73554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73555       };
73556     }
73557   }
73558
73559 }
73560
73561
73562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
73563   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73564
73565   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73566   {
73567     try {
73568       delete arg1;
73569     } catch (std::out_of_range& e) {
73570       {
73571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73572       };
73573     } catch (std::exception& e) {
73574       {
73575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73576       };
73577     } catch (Dali::DaliException e) {
73578       {
73579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73580       };
73581     } catch (...) {
73582       {
73583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73584       };
73585     }
73586   }
73587
73588 }
73589
73590
73591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
73592   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73593   Dali::Toolkit::ControlOrientation::Type arg2 ;
73594
73595   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73596   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
73597   {
73598     try {
73599       (arg1)->SetOrientation(arg2);
73600     } catch (std::out_of_range& e) {
73601       {
73602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73603       };
73604     } catch (std::exception& e) {
73605       {
73606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73607       };
73608     } catch (Dali::DaliException e) {
73609       {
73610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73611       };
73612     } catch (...) {
73613       {
73614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73615       };
73616     }
73617   }
73618
73619 }
73620
73621
73622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
73623   int jresult ;
73624   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73625   Dali::Toolkit::ControlOrientation::Type result;
73626
73627   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73628   {
73629     try {
73630       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
73631     } catch (std::out_of_range& e) {
73632       {
73633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73634       };
73635     } catch (std::exception& e) {
73636       {
73637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73638       };
73639     } catch (Dali::DaliException e) {
73640       {
73641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73642       };
73643     } catch (...) {
73644       {
73645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73646       };
73647     }
73648   }
73649
73650   jresult = (int)result;
73651   return jresult;
73652 }
73653
73654
73655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
73656   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73657   Dali::Property::Map *arg2 = 0 ;
73658
73659   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73660   arg2 = (Dali::Property::Map *)jarg2;
73661   if (!arg2) {
73662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
73663     return ;
73664   }
73665   {
73666     try {
73667       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
73668     } catch (std::out_of_range& e) {
73669       {
73670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73671       };
73672     } catch (std::exception& e) {
73673       {
73674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73675       };
73676     } catch (Dali::DaliException e) {
73677       {
73678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73679       };
73680     } catch (...) {
73681       {
73682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73683       };
73684     }
73685   }
73686
73687 }
73688
73689
73690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
73691   void * jresult ;
73692   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73693   Dali::Property::Map result;
73694
73695   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73696   {
73697     try {
73698       result = (arg1)->GetLayoutProperties();
73699     } catch (std::out_of_range& e) {
73700       {
73701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73702       };
73703     } catch (std::exception& e) {
73704       {
73705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73706       };
73707     } catch (Dali::DaliException e) {
73708       {
73709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73710       };
73711     } catch (...) {
73712       {
73713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73714       };
73715     }
73716   }
73717
73718   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
73719   return jresult;
73720 }
73721
73722
73723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
73724   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73725   unsigned int arg2 ;
73726   Dali::Vector3 *arg3 = 0 ;
73727   Dali::Vector3 *arg4 = 0 ;
73728
73729   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73730   arg2 = (unsigned int)jarg2;
73731   arg3 = (Dali::Vector3 *)jarg3;
73732   if (!arg3) {
73733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73734     return ;
73735   }
73736   arg4 = (Dali::Vector3 *)jarg4;
73737   if (!arg4) {
73738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
73739     return ;
73740   }
73741   {
73742     try {
73743       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
73744     } catch (std::out_of_range& e) {
73745       {
73746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73747       };
73748     } catch (std::exception& e) {
73749       {
73750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73751       };
73752     } catch (Dali::DaliException e) {
73753       {
73754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73755       };
73756     } catch (...) {
73757       {
73758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73759       };
73760     }
73761   }
73762
73763 }
73764
73765
73766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
73767   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73768   Dali::Vector3 *arg2 = 0 ;
73769
73770   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73771   arg2 = (Dali::Vector3 *)jarg2;
73772   if (!arg2) {
73773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73774     return ;
73775   }
73776   {
73777     try {
73778       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
73779     } catch (std::out_of_range& e) {
73780       {
73781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73782       };
73783     } catch (std::exception& e) {
73784       {
73785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73786       };
73787     } catch (Dali::DaliException e) {
73788       {
73789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73790       };
73791     } catch (...) {
73792       {
73793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73794       };
73795     }
73796   }
73797
73798 }
73799
73800
73801 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
73802   float jresult ;
73803   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73804   unsigned int arg2 ;
73805   Dali::Vector3 arg3 ;
73806   Dali::Vector3 *argp3 ;
73807   float result;
73808
73809   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73810   arg2 = (unsigned int)jarg2;
73811   argp3 = (Dali::Vector3 *)jarg3;
73812   if (!argp3) {
73813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
73814     return 0;
73815   }
73816   arg3 = *argp3;
73817   {
73818     try {
73819       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
73820     } catch (std::out_of_range& e) {
73821       {
73822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73823       };
73824     } catch (std::exception& e) {
73825       {
73826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73827       };
73828     } catch (Dali::DaliException e) {
73829       {
73830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73831       };
73832     } catch (...) {
73833       {
73834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73835       };
73836     }
73837   }
73838
73839   jresult = result;
73840   return jresult;
73841 }
73842
73843
73844 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
73845   float jresult ;
73846   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73847   float arg2 ;
73848   float result;
73849
73850   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73851   arg2 = (float)jarg2;
73852   {
73853     try {
73854       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
73855     } catch (std::out_of_range& e) {
73856       {
73857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73858       };
73859     } catch (std::exception& e) {
73860       {
73861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73862       };
73863     } catch (Dali::DaliException e) {
73864       {
73865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73866       };
73867     } catch (...) {
73868       {
73869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73870       };
73871     }
73872   }
73873
73874   jresult = result;
73875   return jresult;
73876 }
73877
73878
73879 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
73880   float jresult ;
73881   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73882   unsigned int arg2 ;
73883   float result;
73884
73885   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73886   arg2 = (unsigned int)jarg2;
73887   {
73888     try {
73889       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
73890     } catch (std::out_of_range& e) {
73891       {
73892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73893       };
73894     } catch (std::exception& e) {
73895       {
73896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73897       };
73898     } catch (Dali::DaliException e) {
73899       {
73900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73901       };
73902     } catch (...) {
73903       {
73904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73905       };
73906     }
73907   }
73908
73909   jresult = result;
73910   return jresult;
73911 }
73912
73913
73914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
73915   void * jresult ;
73916   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73917   float arg2 ;
73918   Dali::Vector3 arg3 ;
73919   Dali::Vector3 *argp3 ;
73920   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
73921
73922   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73923   arg2 = (float)jarg2;
73924   argp3 = (Dali::Vector3 *)jarg3;
73925   if (!argp3) {
73926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
73927     return 0;
73928   }
73929   arg3 = *argp3;
73930   {
73931     try {
73932       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
73933     } catch (std::out_of_range& e) {
73934       {
73935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73936       };
73937     } catch (std::exception& e) {
73938       {
73939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73940       };
73941     } catch (Dali::DaliException e) {
73942       {
73943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73944       };
73945     } catch (...) {
73946       {
73947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73948       };
73949     }
73950   }
73951
73952   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
73953   return jresult;
73954 }
73955
73956
73957 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
73958   float jresult ;
73959   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73960   int arg2 ;
73961   float arg3 ;
73962   Dali::Vector3 *arg4 = 0 ;
73963   float result;
73964
73965   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73966   arg2 = (int)jarg2;
73967   arg3 = (float)jarg3;
73968   arg4 = (Dali::Vector3 *)jarg4;
73969   if (!arg4) {
73970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73971     return 0;
73972   }
73973   {
73974     try {
73975       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
73976     } catch (std::out_of_range& e) {
73977       {
73978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73979       };
73980     } catch (std::exception& e) {
73981       {
73982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73983       };
73984     } catch (Dali::DaliException e) {
73985       {
73986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73987       };
73988     } catch (...) {
73989       {
73990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73991       };
73992     }
73993   }
73994
73995   jresult = result;
73996   return jresult;
73997 }
73998
73999
74000 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
74001   unsigned int jresult ;
74002   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74003   Dali::Vector3 arg2 ;
74004   Dali::Vector3 *argp2 ;
74005   unsigned int result;
74006
74007   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74008   argp2 = (Dali::Vector3 *)jarg2;
74009   if (!argp2) {
74010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74011     return 0;
74012   }
74013   arg2 = *argp2;
74014   {
74015     try {
74016       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
74017     } catch (std::out_of_range& e) {
74018       {
74019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74020       };
74021     } catch (std::exception& e) {
74022       {
74023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74024       };
74025     } catch (Dali::DaliException e) {
74026       {
74027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74028       };
74029     } catch (...) {
74030       {
74031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74032       };
74033     }
74034   }
74035
74036   jresult = result;
74037   return jresult;
74038 }
74039
74040
74041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74042   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74043   unsigned int arg2 ;
74044   Dali::Vector3 *arg3 = 0 ;
74045   Dali::Vector3 *arg4 = 0 ;
74046
74047   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74048   arg2 = (unsigned int)jarg2;
74049   arg3 = (Dali::Vector3 *)jarg3;
74050   if (!arg3) {
74051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74052     return ;
74053   }
74054   arg4 = (Dali::Vector3 *)jarg4;
74055   if (!arg4) {
74056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74057     return ;
74058   }
74059   {
74060     try {
74061       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74062     } catch (std::out_of_range& e) {
74063       {
74064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74065       };
74066     } catch (std::exception& e) {
74067       {
74068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74069       };
74070     } catch (Dali::DaliException e) {
74071       {
74072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74073       };
74074     } catch (...) {
74075       {
74076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74077       };
74078     }
74079   }
74080
74081 }
74082
74083
74084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
74085   void * jresult ;
74086   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74087   Dali::Degree result;
74088
74089   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74090   {
74091     try {
74092       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
74093     } catch (std::out_of_range& e) {
74094       {
74095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74096       };
74097     } catch (std::exception& e) {
74098       {
74099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74100       };
74101     } catch (Dali::DaliException e) {
74102       {
74103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74104       };
74105     } catch (...) {
74106       {
74107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74108       };
74109     }
74110   }
74111
74112   jresult = new Dali::Degree((const Dali::Degree &)result);
74113   return jresult;
74114 }
74115
74116
74117 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
74118   float jresult ;
74119   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74120   float result;
74121
74122   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74123   {
74124     try {
74125       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
74126     } catch (std::out_of_range& e) {
74127       {
74128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74129       };
74130     } catch (std::exception& e) {
74131       {
74132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74133       };
74134     } catch (Dali::DaliException e) {
74135       {
74136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74137       };
74138     } catch (...) {
74139       {
74140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74141       };
74142     }
74143   }
74144
74145   jresult = result;
74146   return jresult;
74147 }
74148
74149
74150 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
74151   float jresult ;
74152   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74153   float result;
74154
74155   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74156   {
74157     try {
74158       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
74159     } catch (std::out_of_range& e) {
74160       {
74161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74162       };
74163     } catch (std::exception& e) {
74164       {
74165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74166       };
74167     } catch (Dali::DaliException e) {
74168       {
74169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74170       };
74171     } catch (...) {
74172       {
74173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74174       };
74175     }
74176   }
74177
74178   jresult = result;
74179   return jresult;
74180 }
74181
74182
74183 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
74184   float jresult ;
74185   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74186   float result;
74187
74188   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74189   {
74190     try {
74191       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
74192     } catch (std::out_of_range& e) {
74193       {
74194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74195       };
74196     } catch (std::exception& e) {
74197       {
74198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74199       };
74200     } catch (Dali::DaliException e) {
74201       {
74202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74203       };
74204     } catch (...) {
74205       {
74206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74207       };
74208     }
74209   }
74210
74211   jresult = result;
74212   return jresult;
74213 }
74214
74215
74216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
74217   int jresult ;
74218   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74219   int arg2 ;
74220   int arg3 ;
74221   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
74222   bool arg5 ;
74223   int result;
74224
74225   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74226   arg2 = (int)jarg2;
74227   arg3 = (int)jarg3;
74228   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
74229   arg5 = jarg5 ? true : false;
74230   {
74231     try {
74232       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
74233     } catch (std::out_of_range& e) {
74234       {
74235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74236       };
74237     } catch (std::exception& e) {
74238       {
74239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74240       };
74241     } catch (Dali::DaliException e) {
74242       {
74243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74244       };
74245     } catch (...) {
74246       {
74247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74248       };
74249     }
74250   }
74251
74252   jresult = result;
74253   return jresult;
74254 }
74255
74256
74257 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
74258   float jresult ;
74259   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74260   float result;
74261
74262   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74263   {
74264     try {
74265       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
74266     } catch (std::out_of_range& e) {
74267       {
74268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74269       };
74270     } catch (std::exception& e) {
74271       {
74272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74273       };
74274     } catch (Dali::DaliException e) {
74275       {
74276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74277       };
74278     } catch (...) {
74279       {
74280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74281       };
74282     }
74283   }
74284
74285   jresult = result;
74286   return jresult;
74287 }
74288
74289
74290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
74291   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74292   Dali::Actor *arg2 = 0 ;
74293   int arg3 ;
74294   Dali::Vector3 *arg4 = 0 ;
74295   Dali::Actor *arg5 = 0 ;
74296
74297   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74298   arg2 = (Dali::Actor *)jarg2;
74299   if (!arg2) {
74300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74301     return ;
74302   }
74303   arg3 = (int)jarg3;
74304   arg4 = (Dali::Vector3 *)jarg4;
74305   if (!arg4) {
74306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74307     return ;
74308   }
74309   arg5 = (Dali::Actor *)jarg5;
74310   if (!arg5) {
74311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
74312     return ;
74313   }
74314   {
74315     try {
74316       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
74317     } catch (std::out_of_range& e) {
74318       {
74319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74320       };
74321     } catch (std::exception& e) {
74322       {
74323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74324       };
74325     } catch (Dali::DaliException e) {
74326       {
74327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74328       };
74329     } catch (...) {
74330       {
74331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74332       };
74333     }
74334   }
74335
74336 }
74337
74338
74339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
74340   void * jresult ;
74341   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74342   int arg2 ;
74343   float arg3 ;
74344   Dali::Vector3 *arg4 = 0 ;
74345   Dali::Vector3 result;
74346
74347   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74348   arg2 = (int)jarg2;
74349   arg3 = (float)jarg3;
74350   arg4 = (Dali::Vector3 *)jarg4;
74351   if (!arg4) {
74352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74353     return 0;
74354   }
74355   {
74356     try {
74357       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
74358     } catch (std::out_of_range& e) {
74359       {
74360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74361       };
74362     } catch (std::exception& e) {
74363       {
74364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74365       };
74366     } catch (Dali::DaliException e) {
74367       {
74368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74369       };
74370     } catch (...) {
74371       {
74372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74373       };
74374     }
74375   }
74376
74377   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
74378   return jresult;
74379 }
74380
74381
74382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
74383   void * jresult ;
74384   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
74385   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
74386
74387   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
74388   {
74389     try {
74390       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
74391     } catch (std::out_of_range& e) {
74392       {
74393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74394       };
74395     } catch (std::exception& e) {
74396       {
74397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74398       };
74399     } catch (Dali::DaliException e) {
74400       {
74401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74402       };
74403     } catch (...) {
74404       {
74405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74406       };
74407     }
74408   }
74409
74410   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
74411   return jresult;
74412 }
74413
74414
74415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
74416   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74417
74418   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74419   {
74420     try {
74421       delete arg1;
74422     } catch (std::out_of_range& e) {
74423       {
74424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74425       };
74426     } catch (std::exception& e) {
74427       {
74428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74429       };
74430     } catch (Dali::DaliException e) {
74431       {
74432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74433       };
74434     } catch (...) {
74435       {
74436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74437       };
74438     }
74439   }
74440
74441 }
74442
74443
74444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
74445   unsigned int jresult ;
74446   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74447   unsigned int result;
74448
74449   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74450   {
74451     try {
74452       result = (unsigned int)(arg1)->GetNumberOfItems();
74453     } catch (std::out_of_range& e) {
74454       {
74455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74456       };
74457     } catch (std::exception& e) {
74458       {
74459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74460       };
74461     } catch (Dali::DaliException e) {
74462       {
74463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74464       };
74465     } catch (...) {
74466       {
74467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74468       };
74469     }
74470   }
74471
74472   jresult = result;
74473   return jresult;
74474 }
74475
74476
74477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
74478   void * jresult ;
74479   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74480   unsigned int arg2 ;
74481   Dali::Actor result;
74482
74483   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74484   arg2 = (unsigned int)jarg2;
74485   {
74486     try {
74487       result = (arg1)->NewItem(arg2);
74488     } catch (std::out_of_range& e) {
74489       {
74490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74491       };
74492     } catch (std::exception& e) {
74493       {
74494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74495       };
74496     } catch (Dali::DaliException e) {
74497       {
74498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74499       };
74500     } catch (...) {
74501       {
74502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74503       };
74504     }
74505   }
74506
74507   jresult = new Dali::Actor((const Dali::Actor &)result);
74508   return jresult;
74509 }
74510
74511
74512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
74513   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74514   unsigned int arg2 ;
74515   Dali::Actor arg3 ;
74516   Dali::Actor *argp3 ;
74517
74518   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74519   arg2 = (unsigned int)jarg2;
74520   argp3 = (Dali::Actor *)jarg3;
74521   if (!argp3) {
74522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74523     return ;
74524   }
74525   arg3 = *argp3;
74526   {
74527     try {
74528       (arg1)->ItemReleased(arg2,arg3);
74529     } catch (std::out_of_range& e) {
74530       {
74531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74532       };
74533     } catch (std::exception& e) {
74534       {
74535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74536       };
74537     } catch (Dali::DaliException e) {
74538       {
74539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74540       };
74541     } catch (...) {
74542       {
74543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74544       };
74545     }
74546   }
74547
74548 }
74549
74550
74551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
74552   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74553   unsigned int arg2 ;
74554   Dali::Actor arg3 ;
74555   Dali::Actor *argp3 ;
74556
74557   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74558   arg2 = (unsigned int)jarg2;
74559   argp3 = (Dali::Actor *)jarg3;
74560   if (!argp3) {
74561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74562     return ;
74563   }
74564   arg3 = *argp3;
74565   {
74566     try {
74567       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
74568     } catch (std::out_of_range& e) {
74569       {
74570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74571       };
74572     } catch (std::exception& e) {
74573       {
74574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74575       };
74576     } catch (Dali::DaliException e) {
74577       {
74578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74579       };
74580     } catch (...) {
74581       {
74582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74583       };
74584     }
74585   }
74586
74587 }
74588
74589
74590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
74591   void * jresult ;
74592   Dali::Toolkit::ItemFactory *result = 0 ;
74593
74594   {
74595     try {
74596       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
74597     } catch (std::out_of_range& e) {
74598       {
74599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74600       };
74601     } catch (std::exception& e) {
74602       {
74603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74604       };
74605     } catch (Dali::DaliException e) {
74606       {
74607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74608       };
74609     } catch (...) {
74610       {
74611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74612       };
74613     }
74614   }
74615
74616   jresult = (void *)result;
74617   return jresult;
74618 }
74619
74620
74621 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) {
74622   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
74623   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
74624   if (director) {
74625     director->swig_connect_director(callback0, callback1, callback2);
74626   }
74627 }
74628
74629
74630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
74631   int jresult ;
74632   int result;
74633
74634   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
74635   jresult = (int)result;
74636   return jresult;
74637 }
74638
74639
74640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
74641   int jresult ;
74642   int result;
74643
74644   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
74645   jresult = (int)result;
74646   return jresult;
74647 }
74648
74649
74650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74651   int jresult ;
74652   int result;
74653
74654   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74655   jresult = (int)result;
74656   return jresult;
74657 }
74658
74659
74660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
74661   int jresult ;
74662   int result;
74663
74664   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
74665   jresult = (int)result;
74666   return jresult;
74667 }
74668
74669
74670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
74671   int jresult ;
74672   int result;
74673
74674   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
74675   jresult = (int)result;
74676   return jresult;
74677 }
74678
74679
74680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
74681   int jresult ;
74682   int result;
74683
74684   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
74685   jresult = (int)result;
74686   return jresult;
74687 }
74688
74689
74690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
74691   int jresult ;
74692   int result;
74693
74694   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
74695   jresult = (int)result;
74696   return jresult;
74697 }
74698
74699
74700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
74701   int jresult ;
74702   int result;
74703
74704   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
74705   jresult = (int)result;
74706   return jresult;
74707 }
74708
74709
74710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
74711   int jresult ;
74712   int result;
74713
74714   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
74715   jresult = (int)result;
74716   return jresult;
74717 }
74718
74719
74720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
74721   int jresult ;
74722   int result;
74723
74724   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
74725   jresult = (int)result;
74726   return jresult;
74727 }
74728
74729
74730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
74731   int jresult ;
74732   int result;
74733
74734   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
74735   jresult = (int)result;
74736   return jresult;
74737 }
74738
74739
74740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
74741   void * jresult ;
74742   Dali::Toolkit::ItemView::Property *result = 0 ;
74743
74744   {
74745     try {
74746       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
74747     } catch (std::out_of_range& e) {
74748       {
74749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74750       };
74751     } catch (std::exception& e) {
74752       {
74753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74754       };
74755     } catch (Dali::DaliException e) {
74756       {
74757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74758       };
74759     } catch (...) {
74760       {
74761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74762       };
74763     }
74764   }
74765
74766   jresult = (void *)result;
74767   return jresult;
74768 }
74769
74770
74771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
74772   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
74773
74774   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
74775   {
74776     try {
74777       delete arg1;
74778     } catch (std::out_of_range& e) {
74779       {
74780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74781       };
74782     } catch (std::exception& e) {
74783       {
74784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74785       };
74786     } catch (Dali::DaliException e) {
74787       {
74788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74789       };
74790     } catch (...) {
74791       {
74792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74793       };
74794     }
74795   }
74796
74797 }
74798
74799
74800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
74801   void * jresult ;
74802   Dali::Toolkit::ItemView *result = 0 ;
74803
74804   {
74805     try {
74806       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
74807     } catch (std::out_of_range& e) {
74808       {
74809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74810       };
74811     } catch (std::exception& e) {
74812       {
74813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74814       };
74815     } catch (Dali::DaliException e) {
74816       {
74817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74818       };
74819     } catch (...) {
74820       {
74821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74822       };
74823     }
74824   }
74825
74826   jresult = (void *)result;
74827   return jresult;
74828 }
74829
74830
74831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
74832   void * jresult ;
74833   Dali::Toolkit::ItemView *arg1 = 0 ;
74834   Dali::Toolkit::ItemView *result = 0 ;
74835
74836   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74837   if (!arg1) {
74838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
74839     return 0;
74840   }
74841   {
74842     try {
74843       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
74844     } catch (std::out_of_range& e) {
74845       {
74846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74847       };
74848     } catch (std::exception& e) {
74849       {
74850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74851       };
74852     } catch (Dali::DaliException e) {
74853       {
74854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74855       };
74856     } catch (...) {
74857       {
74858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74859       };
74860     }
74861   }
74862
74863   jresult = (void *)result;
74864   return jresult;
74865 }
74866
74867
74868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
74869   void * jresult ;
74870   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74871   Dali::Toolkit::ItemView *arg2 = 0 ;
74872   Dali::Toolkit::ItemView *result = 0 ;
74873
74874   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74875   arg2 = (Dali::Toolkit::ItemView *)jarg2;
74876   if (!arg2) {
74877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
74878     return 0;
74879   }
74880   {
74881     try {
74882       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
74883     } catch (std::out_of_range& e) {
74884       {
74885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74886       };
74887     } catch (std::exception& e) {
74888       {
74889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74890       };
74891     } catch (Dali::DaliException e) {
74892       {
74893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74894       };
74895     } catch (...) {
74896       {
74897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74898       };
74899     }
74900   }
74901
74902   jresult = (void *)result;
74903   return jresult;
74904 }
74905
74906
74907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
74908   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74909
74910   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74911   {
74912     try {
74913       delete arg1;
74914     } catch (std::out_of_range& e) {
74915       {
74916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74917       };
74918     } catch (std::exception& e) {
74919       {
74920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74921       };
74922     } catch (Dali::DaliException e) {
74923       {
74924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74925       };
74926     } catch (...) {
74927       {
74928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74929       };
74930     }
74931   }
74932
74933 }
74934
74935
74936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
74937   void * jresult ;
74938   Dali::Toolkit::ItemFactory *arg1 = 0 ;
74939   Dali::Toolkit::ItemView result;
74940
74941   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74942   if (!arg1) {
74943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
74944     return 0;
74945   }
74946   {
74947     try {
74948       result = Dali::Toolkit::ItemView::New(*arg1);
74949     } catch (std::out_of_range& e) {
74950       {
74951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74952       };
74953     } catch (std::exception& e) {
74954       {
74955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74956       };
74957     } catch (Dali::DaliException e) {
74958       {
74959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74960       };
74961     } catch (...) {
74962       {
74963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74964       };
74965     }
74966   }
74967
74968   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
74969   return jresult;
74970 }
74971
74972
74973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
74974   void * jresult ;
74975   Dali::BaseHandle arg1 ;
74976   Dali::BaseHandle *argp1 ;
74977   Dali::Toolkit::ItemView result;
74978
74979   argp1 = (Dali::BaseHandle *)jarg1;
74980   if (!argp1) {
74981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74982     return 0;
74983   }
74984   arg1 = *argp1;
74985   {
74986     try {
74987       result = Dali::Toolkit::ItemView::DownCast(arg1);
74988     } catch (std::out_of_range& e) {
74989       {
74990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74991       };
74992     } catch (std::exception& e) {
74993       {
74994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74995       };
74996     } catch (Dali::DaliException e) {
74997       {
74998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74999       };
75000     } catch (...) {
75001       {
75002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75003       };
75004     }
75005   }
75006
75007   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
75008   return jresult;
75009 }
75010
75011
75012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
75013   unsigned int jresult ;
75014   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75015   unsigned int result;
75016
75017   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75018   {
75019     try {
75020       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
75021     } catch (std::out_of_range& e) {
75022       {
75023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75024       };
75025     } catch (std::exception& e) {
75026       {
75027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75028       };
75029     } catch (Dali::DaliException e) {
75030       {
75031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75032       };
75033     } catch (...) {
75034       {
75035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75036       };
75037     }
75038   }
75039
75040   jresult = result;
75041   return jresult;
75042 }
75043
75044
75045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
75046   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75047   Dali::Toolkit::ItemLayout *arg2 = 0 ;
75048
75049   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75050   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
75051   if (!arg2) {
75052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
75053     return ;
75054   }
75055   {
75056     try {
75057       (arg1)->AddLayout(*arg2);
75058     } catch (std::out_of_range& e) {
75059       {
75060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75061       };
75062     } catch (std::exception& e) {
75063       {
75064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75065       };
75066     } catch (Dali::DaliException e) {
75067       {
75068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75069       };
75070     } catch (...) {
75071       {
75072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75073       };
75074     }
75075   }
75076
75077 }
75078
75079
75080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
75081   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75082   unsigned int arg2 ;
75083
75084   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75085   arg2 = (unsigned int)jarg2;
75086   {
75087     try {
75088       (arg1)->RemoveLayout(arg2);
75089     } catch (std::out_of_range& e) {
75090       {
75091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75092       };
75093     } catch (std::exception& e) {
75094       {
75095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75096       };
75097     } catch (Dali::DaliException e) {
75098       {
75099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75100       };
75101     } catch (...) {
75102       {
75103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75104       };
75105     }
75106   }
75107
75108 }
75109
75110
75111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
75112   void * jresult ;
75113   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75114   unsigned int arg2 ;
75115   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75116
75117   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75118   arg2 = (unsigned int)jarg2;
75119   {
75120     try {
75121       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
75122     } catch (std::out_of_range& e) {
75123       {
75124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75125       };
75126     } catch (std::exception& e) {
75127       {
75128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75129       };
75130     } catch (Dali::DaliException e) {
75131       {
75132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75133       };
75134     } catch (...) {
75135       {
75136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75137       };
75138     }
75139   }
75140
75141   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75142   return jresult;
75143 }
75144
75145
75146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
75147   void * jresult ;
75148   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75149   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75150
75151   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75152   {
75153     try {
75154       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
75155     } catch (std::out_of_range& e) {
75156       {
75157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75158       };
75159     } catch (std::exception& e) {
75160       {
75161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75162       };
75163     } catch (Dali::DaliException e) {
75164       {
75165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75166       };
75167     } catch (...) {
75168       {
75169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75170       };
75171     }
75172   }
75173
75174   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75175   return jresult;
75176 }
75177
75178
75179 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
75180   float jresult ;
75181   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75182   Dali::Toolkit::ItemId arg2 ;
75183   float result;
75184
75185   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75186   arg2 = (Dali::Toolkit::ItemId)jarg2;
75187   {
75188     try {
75189       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
75190     } catch (std::out_of_range& e) {
75191       {
75192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75193       };
75194     } catch (std::exception& e) {
75195       {
75196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75197       };
75198     } catch (Dali::DaliException e) {
75199       {
75200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75201       };
75202     } catch (...) {
75203       {
75204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75205       };
75206     }
75207   }
75208
75209   jresult = result;
75210   return jresult;
75211 }
75212
75213
75214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
75215   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75216   unsigned int arg2 ;
75217   Dali::Vector3 arg3 ;
75218   float arg4 ;
75219   Dali::Vector3 *argp3 ;
75220
75221   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75222   arg2 = (unsigned int)jarg2;
75223   argp3 = (Dali::Vector3 *)jarg3;
75224   if (!argp3) {
75225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75226     return ;
75227   }
75228   arg3 = *argp3;
75229   arg4 = (float)jarg4;
75230   {
75231     try {
75232       (arg1)->ActivateLayout(arg2,arg3,arg4);
75233     } catch (std::out_of_range& e) {
75234       {
75235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75236       };
75237     } catch (std::exception& e) {
75238       {
75239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75240       };
75241     } catch (Dali::DaliException e) {
75242       {
75243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75244       };
75245     } catch (...) {
75246       {
75247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75248       };
75249     }
75250   }
75251
75252 }
75253
75254
75255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
75256   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75257
75258   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75259   {
75260     try {
75261       (arg1)->DeactivateCurrentLayout();
75262     } catch (std::out_of_range& e) {
75263       {
75264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75265       };
75266     } catch (std::exception& e) {
75267       {
75268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75269       };
75270     } catch (Dali::DaliException e) {
75271       {
75272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75273       };
75274     } catch (...) {
75275       {
75276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75277       };
75278     }
75279   }
75280
75281 }
75282
75283
75284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
75285   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75286   float arg2 ;
75287
75288   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75289   arg2 = (float)jarg2;
75290   {
75291     try {
75292       (arg1)->SetMinimumSwipeSpeed(arg2);
75293     } catch (std::out_of_range& e) {
75294       {
75295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75296       };
75297     } catch (std::exception& e) {
75298       {
75299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75300       };
75301     } catch (Dali::DaliException e) {
75302       {
75303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75304       };
75305     } catch (...) {
75306       {
75307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75308       };
75309     }
75310   }
75311
75312 }
75313
75314
75315 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
75316   float jresult ;
75317   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75318   float result;
75319
75320   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75321   {
75322     try {
75323       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
75324     } catch (std::out_of_range& e) {
75325       {
75326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75327       };
75328     } catch (std::exception& e) {
75329       {
75330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75331       };
75332     } catch (Dali::DaliException e) {
75333       {
75334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75335       };
75336     } catch (...) {
75337       {
75338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75339       };
75340     }
75341   }
75342
75343   jresult = result;
75344   return jresult;
75345 }
75346
75347
75348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
75349   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75350   float arg2 ;
75351
75352   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75353   arg2 = (float)jarg2;
75354   {
75355     try {
75356       (arg1)->SetMinimumSwipeDistance(arg2);
75357     } catch (std::out_of_range& e) {
75358       {
75359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75360       };
75361     } catch (std::exception& e) {
75362       {
75363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75364       };
75365     } catch (Dali::DaliException e) {
75366       {
75367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75368       };
75369     } catch (...) {
75370       {
75371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75372       };
75373     }
75374   }
75375
75376 }
75377
75378
75379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
75380   float jresult ;
75381   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75382   float result;
75383
75384   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75385   {
75386     try {
75387       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
75388     } catch (std::out_of_range& e) {
75389       {
75390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75391       };
75392     } catch (std::exception& e) {
75393       {
75394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75395       };
75396     } catch (Dali::DaliException e) {
75397       {
75398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75399       };
75400     } catch (...) {
75401       {
75402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75403       };
75404     }
75405   }
75406
75407   jresult = result;
75408   return jresult;
75409 }
75410
75411
75412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
75413   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75414   float arg2 ;
75415
75416   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75417   arg2 = (float)jarg2;
75418   {
75419     try {
75420       (arg1)->SetWheelScrollDistanceStep(arg2);
75421     } catch (std::out_of_range& e) {
75422       {
75423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75424       };
75425     } catch (std::exception& e) {
75426       {
75427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75428       };
75429     } catch (Dali::DaliException e) {
75430       {
75431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75432       };
75433     } catch (...) {
75434       {
75435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75436       };
75437     }
75438   }
75439
75440 }
75441
75442
75443 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
75444   float jresult ;
75445   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75446   float result;
75447
75448   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75449   {
75450     try {
75451       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
75452     } catch (std::out_of_range& e) {
75453       {
75454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75455       };
75456     } catch (std::exception& e) {
75457       {
75458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75459       };
75460     } catch (Dali::DaliException e) {
75461       {
75462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75463       };
75464     } catch (...) {
75465       {
75466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75467       };
75468     }
75469   }
75470
75471   jresult = result;
75472   return jresult;
75473 }
75474
75475
75476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
75477   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75478   bool arg2 ;
75479
75480   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75481   arg2 = jarg2 ? true : false;
75482   {
75483     try {
75484       (arg1)->SetAnchoring(arg2);
75485     } catch (std::out_of_range& e) {
75486       {
75487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75488       };
75489     } catch (std::exception& e) {
75490       {
75491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75492       };
75493     } catch (Dali::DaliException e) {
75494       {
75495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75496       };
75497     } catch (...) {
75498       {
75499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75500       };
75501     }
75502   }
75503
75504 }
75505
75506 //// ========================= end of part 3 =============================
75507
75508 //// ========================== start part 4 ===============================
75509
75510
75511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
75512   unsigned int jresult ;
75513   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75514   bool result;
75515
75516   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75517   {
75518     try {
75519       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
75520     } catch (std::out_of_range& e) {
75521       {
75522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75523       };
75524     } catch (std::exception& e) {
75525       {
75526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75527       };
75528     } catch (Dali::DaliException e) {
75529       {
75530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75531       };
75532     } catch (...) {
75533       {
75534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75535       };
75536     }
75537   }
75538
75539   jresult = result;
75540   return jresult;
75541 }
75542
75543
75544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
75545   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75546   float arg2 ;
75547
75548   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75549   arg2 = (float)jarg2;
75550   {
75551     try {
75552       (arg1)->SetAnchoringDuration(arg2);
75553     } catch (std::out_of_range& e) {
75554       {
75555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75556       };
75557     } catch (std::exception& e) {
75558       {
75559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75560       };
75561     } catch (Dali::DaliException e) {
75562       {
75563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75564       };
75565     } catch (...) {
75566       {
75567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75568       };
75569     }
75570   }
75571
75572 }
75573
75574
75575 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
75576   float jresult ;
75577   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75578   float result;
75579
75580   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75581   {
75582     try {
75583       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
75584     } catch (std::out_of_range& e) {
75585       {
75586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75587       };
75588     } catch (std::exception& e) {
75589       {
75590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75591       };
75592     } catch (Dali::DaliException e) {
75593       {
75594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75595       };
75596     } catch (...) {
75597       {
75598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75599       };
75600     }
75601   }
75602
75603   jresult = result;
75604   return jresult;
75605 }
75606
75607
75608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
75609   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75610   Dali::Toolkit::ItemId arg2 ;
75611   float arg3 ;
75612
75613   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75614   arg2 = (Dali::Toolkit::ItemId)jarg2;
75615   arg3 = (float)jarg3;
75616   {
75617     try {
75618       (arg1)->ScrollToItem(arg2,arg3);
75619     } catch (std::out_of_range& e) {
75620       {
75621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75622       };
75623     } catch (std::exception& e) {
75624       {
75625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75626       };
75627     } catch (Dali::DaliException e) {
75628       {
75629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75630       };
75631     } catch (...) {
75632       {
75633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75634       };
75635     }
75636   }
75637
75638 }
75639
75640
75641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
75642   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75643   float arg2 ;
75644
75645   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75646   arg2 = (float)jarg2;
75647   {
75648     try {
75649       (arg1)->SetRefreshInterval(arg2);
75650     } catch (std::out_of_range& e) {
75651       {
75652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75653       };
75654     } catch (std::exception& e) {
75655       {
75656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75657       };
75658     } catch (Dali::DaliException e) {
75659       {
75660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75661       };
75662     } catch (...) {
75663       {
75664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75665       };
75666     }
75667   }
75668
75669 }
75670
75671
75672 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
75673   float jresult ;
75674   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75675   float result;
75676
75677   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75678   {
75679     try {
75680       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
75681     } catch (std::out_of_range& e) {
75682       {
75683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75684       };
75685     } catch (std::exception& e) {
75686       {
75687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75688       };
75689     } catch (Dali::DaliException e) {
75690       {
75691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75692       };
75693     } catch (...) {
75694       {
75695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75696       };
75697     }
75698   }
75699
75700   jresult = result;
75701   return jresult;
75702 }
75703
75704
75705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
75706   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75707
75708   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75709   {
75710     try {
75711       (arg1)->Refresh();
75712     } catch (std::out_of_range& e) {
75713       {
75714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75715       };
75716     } catch (std::exception& e) {
75717       {
75718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75719       };
75720     } catch (Dali::DaliException e) {
75721       {
75722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75723       };
75724     } catch (...) {
75725       {
75726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75727       };
75728     }
75729   }
75730
75731 }
75732
75733
75734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
75735   void * jresult ;
75736   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75737   Dali::Toolkit::ItemId arg2 ;
75738   Dali::Actor result;
75739
75740   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75741   arg2 = (Dali::Toolkit::ItemId)jarg2;
75742   {
75743     try {
75744       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
75745     } catch (std::out_of_range& e) {
75746       {
75747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75748       };
75749     } catch (std::exception& e) {
75750       {
75751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75752       };
75753     } catch (Dali::DaliException e) {
75754       {
75755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75756       };
75757     } catch (...) {
75758       {
75759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75760       };
75761     }
75762   }
75763
75764   jresult = new Dali::Actor((const Dali::Actor &)result);
75765   return jresult;
75766 }
75767
75768
75769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
75770   unsigned int jresult ;
75771   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75772   Dali::Actor arg2 ;
75773   Dali::Actor *argp2 ;
75774   Dali::Toolkit::ItemId result;
75775
75776   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75777   argp2 = (Dali::Actor *)jarg2;
75778   if (!argp2) {
75779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75780     return 0;
75781   }
75782   arg2 = *argp2;
75783   {
75784     try {
75785       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
75786     } catch (std::out_of_range& e) {
75787       {
75788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75789       };
75790     } catch (std::exception& e) {
75791       {
75792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75793       };
75794     } catch (Dali::DaliException e) {
75795       {
75796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75797       };
75798     } catch (...) {
75799       {
75800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75801       };
75802     }
75803   }
75804
75805   jresult = result;
75806   return jresult;
75807 }
75808
75809
75810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
75811   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75812   Dali::Toolkit::Item arg2 ;
75813   float arg3 ;
75814   Dali::Toolkit::Item *argp2 ;
75815
75816   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75817   argp2 = (Dali::Toolkit::Item *)jarg2;
75818   if (!argp2) {
75819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
75820     return ;
75821   }
75822   arg2 = *argp2;
75823   arg3 = (float)jarg3;
75824   {
75825     try {
75826       (arg1)->InsertItem(arg2,arg3);
75827     } catch (std::out_of_range& e) {
75828       {
75829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75830       };
75831     } catch (std::exception& e) {
75832       {
75833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75834       };
75835     } catch (Dali::DaliException e) {
75836       {
75837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75838       };
75839     } catch (...) {
75840       {
75841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75842       };
75843     }
75844   }
75845
75846 }
75847
75848
75849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
75850   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75851   Dali::Toolkit::ItemContainer *arg2 = 0 ;
75852   float arg3 ;
75853
75854   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75855   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
75856   if (!arg2) {
75857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
75858     return ;
75859   }
75860   arg3 = (float)jarg3;
75861   {
75862     try {
75863       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
75864     } catch (std::out_of_range& e) {
75865       {
75866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75867       };
75868     } catch (std::exception& e) {
75869       {
75870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75871       };
75872     } catch (Dali::DaliException e) {
75873       {
75874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75875       };
75876     } catch (...) {
75877       {
75878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75879       };
75880     }
75881   }
75882
75883 }
75884
75885
75886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
75887   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75888   Dali::Toolkit::ItemId arg2 ;
75889   float arg3 ;
75890
75891   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75892   arg2 = (Dali::Toolkit::ItemId)jarg2;
75893   arg3 = (float)jarg3;
75894   {
75895     try {
75896       (arg1)->RemoveItem(arg2,arg3);
75897     } catch (std::out_of_range& e) {
75898       {
75899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75900       };
75901     } catch (std::exception& e) {
75902       {
75903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75904       };
75905     } catch (Dali::DaliException e) {
75906       {
75907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75908       };
75909     } catch (...) {
75910       {
75911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75912       };
75913     }
75914   }
75915
75916 }
75917
75918
75919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
75920   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75921   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
75922   float arg3 ;
75923
75924   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75925   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
75926   if (!arg2) {
75927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
75928     return ;
75929   }
75930   arg3 = (float)jarg3;
75931   {
75932     try {
75933       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
75934     } catch (std::out_of_range& e) {
75935       {
75936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75937       };
75938     } catch (std::exception& e) {
75939       {
75940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75941       };
75942     } catch (Dali::DaliException e) {
75943       {
75944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75945       };
75946     } catch (...) {
75947       {
75948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75949       };
75950     }
75951   }
75952
75953 }
75954
75955
75956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
75957   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75958   Dali::Toolkit::Item arg2 ;
75959   float arg3 ;
75960   Dali::Toolkit::Item *argp2 ;
75961
75962   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75963   argp2 = (Dali::Toolkit::Item *)jarg2;
75964   if (!argp2) {
75965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
75966     return ;
75967   }
75968   arg2 = *argp2;
75969   arg3 = (float)jarg3;
75970   {
75971     try {
75972       (arg1)->ReplaceItem(arg2,arg3);
75973     } catch (std::out_of_range& e) {
75974       {
75975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75976       };
75977     } catch (std::exception& e) {
75978       {
75979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75980       };
75981     } catch (Dali::DaliException e) {
75982       {
75983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75984       };
75985     } catch (...) {
75986       {
75987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75988       };
75989     }
75990   }
75991
75992 }
75993
75994
75995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
75996   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75997   Dali::Toolkit::ItemContainer *arg2 = 0 ;
75998   float arg3 ;
75999
76000   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76001   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
76002   if (!arg2) {
76003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76004     return ;
76005   }
76006   arg3 = (float)jarg3;
76007   {
76008     try {
76009       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76010     } catch (std::out_of_range& e) {
76011       {
76012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76013       };
76014     } catch (std::exception& e) {
76015       {
76016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76017       };
76018     } catch (Dali::DaliException e) {
76019       {
76020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76021       };
76022     } catch (...) {
76023       {
76024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76025       };
76026     }
76027   }
76028
76029 }
76030
76031
76032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
76033   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76034   Dali::Vector3 *arg2 = 0 ;
76035
76036   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76037   arg2 = (Dali::Vector3 *)jarg2;
76038   if (!arg2) {
76039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76040     return ;
76041   }
76042   {
76043     try {
76044       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
76045     } catch (std::out_of_range& e) {
76046       {
76047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76048       };
76049     } catch (std::exception& e) {
76050       {
76051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76052       };
76053     } catch (Dali::DaliException e) {
76054       {
76055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76056       };
76057     } catch (...) {
76058       {
76059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76060       };
76061     }
76062   }
76063
76064 }
76065
76066
76067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
76068   void * jresult ;
76069   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76070   Dali::Vector3 result;
76071
76072   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76073   {
76074     try {
76075       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
76076     } catch (std::out_of_range& e) {
76077       {
76078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76079       };
76080     } catch (std::exception& e) {
76081       {
76082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76083       };
76084     } catch (Dali::DaliException e) {
76085       {
76086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76087       };
76088     } catch (...) {
76089       {
76090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76091       };
76092     }
76093   }
76094
76095   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76096   return jresult;
76097 }
76098
76099
76100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
76101   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76102   Dali::Vector3 *arg2 = 0 ;
76103
76104   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76105   arg2 = (Dali::Vector3 *)jarg2;
76106   if (!arg2) {
76107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76108     return ;
76109   }
76110   {
76111     try {
76112       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
76113     } catch (std::out_of_range& e) {
76114       {
76115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76116       };
76117     } catch (std::exception& e) {
76118       {
76119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76120       };
76121     } catch (Dali::DaliException e) {
76122       {
76123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76124       };
76125     } catch (...) {
76126       {
76127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76128       };
76129     }
76130   }
76131
76132 }
76133
76134
76135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
76136   void * jresult ;
76137   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76138   Dali::Vector3 result;
76139
76140   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76141   {
76142     try {
76143       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
76144     } catch (std::out_of_range& e) {
76145       {
76146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76147       };
76148     } catch (std::exception& e) {
76149       {
76150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76151       };
76152     } catch (Dali::DaliException e) {
76153       {
76154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76155       };
76156     } catch (...) {
76157       {
76158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76159       };
76160     }
76161   }
76162
76163   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76164   return jresult;
76165 }
76166
76167
76168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
76169   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76170   Dali::Toolkit::ItemRange *arg2 = 0 ;
76171
76172   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76173   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
76174   if (!arg2) {
76175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
76176     return ;
76177   }
76178   {
76179     try {
76180       (arg1)->GetItemsRange(*arg2);
76181     } catch (std::out_of_range& e) {
76182       {
76183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76184       };
76185     } catch (std::exception& e) {
76186       {
76187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76188       };
76189     } catch (Dali::DaliException e) {
76190       {
76191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76192       };
76193     } catch (...) {
76194       {
76195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76196       };
76197     }
76198   }
76199
76200 }
76201
76202
76203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
76204   void * jresult ;
76205   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76206   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
76207
76208   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76209   {
76210     try {
76211       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
76212     } catch (std::out_of_range& e) {
76213       {
76214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76215       };
76216     } catch (std::exception& e) {
76217       {
76218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76219       };
76220     } catch (Dali::DaliException e) {
76221       {
76222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76223       };
76224     } catch (...) {
76225       {
76226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76227       };
76228     }
76229   }
76230
76231   jresult = (void *)result;
76232   return jresult;
76233 }
76234
76235
76236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
76237   Dali::Vector3 *arg1 = 0 ;
76238   PropertyInputContainer *arg2 = 0 ;
76239
76240   arg1 = (Dali::Vector3 *)jarg1;
76241   if (!arg1) {
76242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
76243     return ;
76244   }
76245   arg2 = (PropertyInputContainer *)jarg2;
76246   if (!arg2) {
76247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
76248     return ;
76249   }
76250   {
76251     try {
76252       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
76253     } catch (std::out_of_range& e) {
76254       {
76255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76256       };
76257     } catch (std::exception& e) {
76258       {
76259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76260       };
76261     } catch (Dali::DaliException e) {
76262       {
76263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76264       };
76265     } catch (...) {
76266       {
76267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76268       };
76269     }
76270   }
76271
76272 }
76273
76274
76275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
76276   Dali::Vector3 *arg1 = 0 ;
76277   PropertyInputContainer *arg2 = 0 ;
76278
76279   arg1 = (Dali::Vector3 *)jarg1;
76280   if (!arg1) {
76281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
76282     return ;
76283   }
76284   arg2 = (PropertyInputContainer *)jarg2;
76285   if (!arg2) {
76286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
76287     return ;
76288   }
76289   {
76290     try {
76291       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
76292     } catch (std::out_of_range& e) {
76293       {
76294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76295       };
76296     } catch (std::exception& e) {
76297       {
76298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76299       };
76300     } catch (Dali::DaliException e) {
76301       {
76302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76303       };
76304     } catch (...) {
76305       {
76306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76307       };
76308     }
76309   }
76310
76311 }
76312
76313
76314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
76315   void * jresult ;
76316   Dali::Toolkit::ScrollViewEffect *result = 0 ;
76317
76318   {
76319     try {
76320       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
76321     } catch (std::out_of_range& e) {
76322       {
76323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76324       };
76325     } catch (std::exception& e) {
76326       {
76327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76328       };
76329     } catch (Dali::DaliException e) {
76330       {
76331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76332       };
76333     } catch (...) {
76334       {
76335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76336       };
76337     }
76338   }
76339
76340   jresult = (void *)result;
76341   return jresult;
76342 }
76343
76344
76345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
76346   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
76347
76348   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
76349   {
76350     try {
76351       delete arg1;
76352     } catch (std::out_of_range& e) {
76353       {
76354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76355       };
76356     } catch (std::exception& e) {
76357       {
76358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76359       };
76360     } catch (Dali::DaliException e) {
76361       {
76362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76363       };
76364     } catch (...) {
76365       {
76366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76367       };
76368     }
76369   }
76370
76371 }
76372
76373
76374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
76375   void * jresult ;
76376   Dali::Path arg1 ;
76377   Dali::Vector3 *arg2 = 0 ;
76378   Dali::Property::Index arg3 ;
76379   Dali::Vector3 *arg4 = 0 ;
76380   unsigned int arg5 ;
76381   Dali::Path *argp1 ;
76382   Dali::Toolkit::ScrollViewPagePathEffect result;
76383
76384   argp1 = (Dali::Path *)jarg1;
76385   if (!argp1) {
76386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
76387     return 0;
76388   }
76389   arg1 = *argp1;
76390   arg2 = (Dali::Vector3 *)jarg2;
76391   if (!arg2) {
76392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76393     return 0;
76394   }
76395   arg3 = (Dali::Property::Index)jarg3;
76396   arg4 = (Dali::Vector3 *)jarg4;
76397   if (!arg4) {
76398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76399     return 0;
76400   }
76401   arg5 = (unsigned int)jarg5;
76402   {
76403     try {
76404       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
76405     } catch (std::out_of_range& e) {
76406       {
76407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76408       };
76409     } catch (std::exception& e) {
76410       {
76411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76412       };
76413     } catch (Dali::DaliException e) {
76414       {
76415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76416       };
76417     } catch (...) {
76418       {
76419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76420       };
76421     }
76422   }
76423
76424   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
76425   return jresult;
76426 }
76427
76428
76429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
76430   void * jresult ;
76431   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
76432
76433   {
76434     try {
76435       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
76436     } catch (std::out_of_range& e) {
76437       {
76438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76439       };
76440     } catch (std::exception& e) {
76441       {
76442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76443       };
76444     } catch (Dali::DaliException e) {
76445       {
76446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76447       };
76448     } catch (...) {
76449       {
76450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76451       };
76452     }
76453   }
76454
76455   jresult = (void *)result;
76456   return jresult;
76457 }
76458
76459
76460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
76461   void * jresult ;
76462   Dali::BaseHandle arg1 ;
76463   Dali::BaseHandle *argp1 ;
76464   Dali::Toolkit::ScrollViewPagePathEffect result;
76465
76466   argp1 = (Dali::BaseHandle *)jarg1;
76467   if (!argp1) {
76468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76469     return 0;
76470   }
76471   arg1 = *argp1;
76472   {
76473     try {
76474       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
76475     } catch (std::out_of_range& e) {
76476       {
76477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76478       };
76479     } catch (std::exception& e) {
76480       {
76481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76482       };
76483     } catch (Dali::DaliException e) {
76484       {
76485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76486       };
76487     } catch (...) {
76488       {
76489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76490       };
76491     }
76492   }
76493
76494   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
76495   return jresult;
76496 }
76497
76498
76499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
76500   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
76501   Dali::Actor arg2 ;
76502   unsigned int arg3 ;
76503   Dali::Actor *argp2 ;
76504
76505   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
76506   argp2 = (Dali::Actor *)jarg2;
76507   if (!argp2) {
76508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76509     return ;
76510   }
76511   arg2 = *argp2;
76512   arg3 = (unsigned int)jarg3;
76513   {
76514     try {
76515       (arg1)->ApplyToPage(arg2,arg3);
76516     } catch (std::out_of_range& e) {
76517       {
76518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76519       };
76520     } catch (std::exception& e) {
76521       {
76522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76523       };
76524     } catch (Dali::DaliException e) {
76525       {
76526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76527       };
76528     } catch (...) {
76529       {
76530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76531       };
76532     }
76533   }
76534
76535 }
76536
76537
76538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
76539   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
76540
76541   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
76542   {
76543     try {
76544       delete arg1;
76545     } catch (std::out_of_range& e) {
76546       {
76547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76548       };
76549     } catch (std::exception& e) {
76550       {
76551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76552       };
76553     } catch (Dali::DaliException e) {
76554       {
76555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76556       };
76557     } catch (...) {
76558       {
76559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76560       };
76561     }
76562   }
76563
76564 }
76565
76566
76567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
76568   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76569   Dali::Toolkit::ClampState arg2 ;
76570
76571   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76572   arg2 = (Dali::Toolkit::ClampState)jarg2;
76573   if (arg1) (arg1)->x = arg2;
76574 }
76575
76576
76577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
76578   int jresult ;
76579   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76580   Dali::Toolkit::ClampState result;
76581
76582   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76583   result = (Dali::Toolkit::ClampState) ((arg1)->x);
76584   jresult = (int)result;
76585   return jresult;
76586 }
76587
76588
76589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
76590   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76591   Dali::Toolkit::ClampState arg2 ;
76592
76593   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76594   arg2 = (Dali::Toolkit::ClampState)jarg2;
76595   if (arg1) (arg1)->y = arg2;
76596 }
76597
76598
76599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
76600   int jresult ;
76601   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76602   Dali::Toolkit::ClampState result;
76603
76604   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76605   result = (Dali::Toolkit::ClampState) ((arg1)->y);
76606   jresult = (int)result;
76607   return jresult;
76608 }
76609
76610
76611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
76612   void * jresult ;
76613   Dali::Toolkit::ClampState2D *result = 0 ;
76614
76615   {
76616     try {
76617       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
76618     } catch (std::out_of_range& e) {
76619       {
76620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76621       };
76622     } catch (std::exception& e) {
76623       {
76624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76625       };
76626     } catch (Dali::DaliException e) {
76627       {
76628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76629       };
76630     } catch (...) {
76631       {
76632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76633       };
76634     }
76635   }
76636
76637   jresult = (void *)result;
76638   return jresult;
76639 }
76640
76641
76642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
76643   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76644
76645   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76646   {
76647     try {
76648       delete arg1;
76649     } catch (std::out_of_range& e) {
76650       {
76651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76652       };
76653     } catch (std::exception& e) {
76654       {
76655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76656       };
76657     } catch (Dali::DaliException e) {
76658       {
76659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76660       };
76661     } catch (...) {
76662       {
76663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76664       };
76665     }
76666   }
76667
76668 }
76669
76670
76671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
76672   void * jresult ;
76673   float arg1 ;
76674   float arg2 ;
76675   bool arg3 ;
76676   Dali::Toolkit::RulerDomain *result = 0 ;
76677
76678   arg1 = (float)jarg1;
76679   arg2 = (float)jarg2;
76680   arg3 = jarg3 ? true : false;
76681   {
76682     try {
76683       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
76684     } catch (std::out_of_range& e) {
76685       {
76686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76687       };
76688     } catch (std::exception& e) {
76689       {
76690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76691       };
76692     } catch (Dali::DaliException e) {
76693       {
76694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76695       };
76696     } catch (...) {
76697       {
76698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76699       };
76700     }
76701   }
76702
76703   jresult = (void *)result;
76704   return jresult;
76705 }
76706
76707
76708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
76709   void * jresult ;
76710   float arg1 ;
76711   float arg2 ;
76712   Dali::Toolkit::RulerDomain *result = 0 ;
76713
76714   arg1 = (float)jarg1;
76715   arg2 = (float)jarg2;
76716   {
76717     try {
76718       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
76719     } catch (std::out_of_range& e) {
76720       {
76721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76722       };
76723     } catch (std::exception& e) {
76724       {
76725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76726       };
76727     } catch (Dali::DaliException e) {
76728       {
76729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76730       };
76731     } catch (...) {
76732       {
76733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76734       };
76735     }
76736   }
76737
76738   jresult = (void *)result;
76739   return jresult;
76740 }
76741
76742
76743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
76744   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76745   float arg2 ;
76746
76747   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76748   arg2 = (float)jarg2;
76749   if (arg1) (arg1)->min = arg2;
76750 }
76751
76752
76753 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
76754   float jresult ;
76755   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76756   float result;
76757
76758   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76759   result = (float) ((arg1)->min);
76760   jresult = result;
76761   return jresult;
76762 }
76763
76764
76765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
76766   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76767   float arg2 ;
76768
76769   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76770   arg2 = (float)jarg2;
76771   if (arg1) (arg1)->max = arg2;
76772 }
76773
76774
76775 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
76776   float jresult ;
76777   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76778   float result;
76779
76780   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76781   result = (float) ((arg1)->max);
76782   jresult = result;
76783   return jresult;
76784 }
76785
76786
76787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
76788   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76789   bool arg2 ;
76790
76791   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76792   arg2 = jarg2 ? true : false;
76793   if (arg1) (arg1)->enabled = arg2;
76794 }
76795
76796
76797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
76798   unsigned int jresult ;
76799   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76800   bool result;
76801
76802   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76803   result = (bool) ((arg1)->enabled);
76804   jresult = result;
76805   return jresult;
76806 }
76807
76808
76809 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
76810   float jresult ;
76811   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76812   float arg2 ;
76813   float arg3 ;
76814   float arg4 ;
76815   float result;
76816
76817   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76818   arg2 = (float)jarg2;
76819   arg3 = (float)jarg3;
76820   arg4 = (float)jarg4;
76821   {
76822     try {
76823       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
76824     } catch (std::out_of_range& e) {
76825       {
76826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76827       };
76828     } catch (std::exception& e) {
76829       {
76830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76831       };
76832     } catch (Dali::DaliException e) {
76833       {
76834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76835       };
76836     } catch (...) {
76837       {
76838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76839       };
76840     }
76841   }
76842
76843   jresult = result;
76844   return jresult;
76845 }
76846
76847
76848 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
76849   float jresult ;
76850   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76851   float arg2 ;
76852   float arg3 ;
76853   float result;
76854
76855   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76856   arg2 = (float)jarg2;
76857   arg3 = (float)jarg3;
76858   {
76859     try {
76860       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
76861     } catch (std::out_of_range& e) {
76862       {
76863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76864       };
76865     } catch (std::exception& e) {
76866       {
76867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76868       };
76869     } catch (Dali::DaliException e) {
76870       {
76871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76872       };
76873     } catch (...) {
76874       {
76875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76876       };
76877     }
76878   }
76879
76880   jresult = result;
76881   return jresult;
76882 }
76883
76884
76885 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
76886   float jresult ;
76887   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76888   float arg2 ;
76889   float result;
76890
76891   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76892   arg2 = (float)jarg2;
76893   {
76894     try {
76895       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
76896     } catch (std::out_of_range& e) {
76897       {
76898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76899       };
76900     } catch (std::exception& e) {
76901       {
76902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76903       };
76904     } catch (Dali::DaliException e) {
76905       {
76906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76907       };
76908     } catch (...) {
76909       {
76910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76911       };
76912     }
76913   }
76914
76915   jresult = result;
76916   return jresult;
76917 }
76918
76919
76920 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
76921   float jresult ;
76922   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76923   float arg2 ;
76924   float arg3 ;
76925   float arg4 ;
76926   Dali::Toolkit::ClampState *arg5 = 0 ;
76927   float result;
76928
76929   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76930   arg2 = (float)jarg2;
76931   arg3 = (float)jarg3;
76932   arg4 = (float)jarg4;
76933   arg5 = (Dali::Toolkit::ClampState *)jarg5;
76934   if (!arg5) {
76935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
76936     return 0;
76937   }
76938   {
76939     try {
76940       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
76941     } catch (std::out_of_range& e) {
76942       {
76943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76944       };
76945     } catch (std::exception& e) {
76946       {
76947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76948       };
76949     } catch (Dali::DaliException e) {
76950       {
76951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76952       };
76953     } catch (...) {
76954       {
76955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76956       };
76957     }
76958   }
76959
76960   jresult = result;
76961   return jresult;
76962 }
76963
76964
76965 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
76966   float jresult ;
76967   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76968   float result;
76969
76970   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76971   {
76972     try {
76973       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
76974     } catch (std::out_of_range& e) {
76975       {
76976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76977       };
76978     } catch (std::exception& e) {
76979       {
76980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76981       };
76982     } catch (Dali::DaliException e) {
76983       {
76984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76985       };
76986     } catch (...) {
76987       {
76988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76989       };
76990     }
76991   }
76992
76993   jresult = result;
76994   return jresult;
76995 }
76996
76997
76998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
76999   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77000
77001   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77002   {
77003     try {
77004       delete arg1;
77005     } catch (std::out_of_range& e) {
77006       {
77007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77008       };
77009     } catch (std::exception& e) {
77010       {
77011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77012       };
77013     } catch (Dali::DaliException e) {
77014       {
77015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77016       };
77017     } catch (...) {
77018       {
77019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77020       };
77021     }
77022   }
77023
77024 }
77025
77026
77027 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
77028   float jresult ;
77029   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77030   float arg2 ;
77031   float arg3 ;
77032   float result;
77033
77034   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77035   arg2 = (float)jarg2;
77036   arg3 = (float)jarg3;
77037   {
77038     try {
77039       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
77040     } catch (std::out_of_range& e) {
77041       {
77042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77043       };
77044     } catch (std::exception& e) {
77045       {
77046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77047       };
77048     } catch (Dali::DaliException e) {
77049       {
77050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77051       };
77052     } catch (...) {
77053       {
77054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77055       };
77056     }
77057   }
77058
77059   jresult = result;
77060   return jresult;
77061 }
77062
77063
77064 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
77065   float jresult ;
77066   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77067   float arg2 ;
77068   float result;
77069
77070   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77071   arg2 = (float)jarg2;
77072   {
77073     try {
77074       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
77075     } catch (std::out_of_range& e) {
77076       {
77077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77078       };
77079     } catch (std::exception& e) {
77080       {
77081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77082       };
77083     } catch (Dali::DaliException e) {
77084       {
77085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77086       };
77087     } catch (...) {
77088       {
77089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77090       };
77091     }
77092   }
77093
77094   jresult = result;
77095   return jresult;
77096 }
77097
77098
77099 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
77100   float jresult ;
77101   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77102   unsigned int arg2 ;
77103   unsigned int *arg3 = 0 ;
77104   bool arg4 ;
77105   float result;
77106
77107   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77108   arg2 = (unsigned int)jarg2;
77109   arg3 = (unsigned int *)jarg3;
77110   arg4 = jarg4 ? true : false;
77111   {
77112     try {
77113       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
77114     } catch (std::out_of_range& e) {
77115       {
77116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77117       };
77118     } catch (std::exception& e) {
77119       {
77120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77121       };
77122     } catch (Dali::DaliException e) {
77123       {
77124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77125       };
77126     } catch (...) {
77127       {
77128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77129       };
77130     }
77131   }
77132
77133   jresult = result;
77134   return jresult;
77135 }
77136
77137
77138 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
77139   unsigned int jresult ;
77140   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77141   float arg2 ;
77142   bool arg3 ;
77143   unsigned int result;
77144
77145   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77146   arg2 = (float)jarg2;
77147   arg3 = jarg3 ? true : false;
77148   {
77149     try {
77150       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
77151     } catch (std::out_of_range& e) {
77152       {
77153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77154       };
77155     } catch (std::exception& e) {
77156       {
77157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77158       };
77159     } catch (Dali::DaliException e) {
77160       {
77161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77162       };
77163     } catch (...) {
77164       {
77165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77166       };
77167     }
77168   }
77169
77170   jresult = result;
77171   return jresult;
77172 }
77173
77174
77175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
77176   unsigned int jresult ;
77177   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77178   unsigned int result;
77179
77180   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77181   {
77182     try {
77183       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
77184     } catch (std::out_of_range& e) {
77185       {
77186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77187       };
77188     } catch (std::exception& e) {
77189       {
77190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77191       };
77192     } catch (Dali::DaliException e) {
77193       {
77194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77195       };
77196     } catch (...) {
77197       {
77198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77199       };
77200     }
77201   }
77202
77203   jresult = result;
77204   return jresult;
77205 }
77206
77207
77208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
77209   int jresult ;
77210   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77211   Dali::Toolkit::Ruler::RulerType result;
77212
77213   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77214   {
77215     try {
77216       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
77217     } catch (std::out_of_range& e) {
77218       {
77219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77220       };
77221     } catch (std::exception& e) {
77222       {
77223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77224       };
77225     } catch (Dali::DaliException e) {
77226       {
77227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77228       };
77229     } catch (...) {
77230       {
77231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77232       };
77233     }
77234   }
77235
77236   jresult = (int)result;
77237   return jresult;
77238 }
77239
77240
77241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
77242   unsigned int jresult ;
77243   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77244   bool result;
77245
77246   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77247   {
77248     try {
77249       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
77250     } catch (std::out_of_range& e) {
77251       {
77252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77253       };
77254     } catch (std::exception& e) {
77255       {
77256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77257       };
77258     } catch (Dali::DaliException e) {
77259       {
77260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77261       };
77262     } catch (...) {
77263       {
77264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77265       };
77266     }
77267   }
77268
77269   jresult = result;
77270   return jresult;
77271 }
77272
77273
77274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
77275   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77276
77277   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77278   {
77279     try {
77280       (arg1)->Enable();
77281     } catch (std::out_of_range& e) {
77282       {
77283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77284       };
77285     } catch (std::exception& e) {
77286       {
77287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77288       };
77289     } catch (Dali::DaliException e) {
77290       {
77291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77292       };
77293     } catch (...) {
77294       {
77295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77296       };
77297     }
77298   }
77299
77300 }
77301
77302
77303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
77304   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77305
77306   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77307   {
77308     try {
77309       (arg1)->Disable();
77310     } catch (std::out_of_range& e) {
77311       {
77312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77313       };
77314     } catch (std::exception& e) {
77315       {
77316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77317       };
77318     } catch (Dali::DaliException e) {
77319       {
77320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77321       };
77322     } catch (...) {
77323       {
77324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77325       };
77326     }
77327   }
77328
77329 }
77330
77331
77332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
77333   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77334   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
77335   Dali::Toolkit::RulerDomain *argp2 ;
77336
77337   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77338   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
77339   if (!argp2) {
77340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
77341     return ;
77342   }
77343   arg2 = *argp2;
77344   {
77345     try {
77346       (arg1)->SetDomain(arg2);
77347     } catch (std::out_of_range& e) {
77348       {
77349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77350       };
77351     } catch (std::exception& e) {
77352       {
77353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77354       };
77355     } catch (Dali::DaliException e) {
77356       {
77357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77358       };
77359     } catch (...) {
77360       {
77361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77362       };
77363     }
77364   }
77365
77366 }
77367
77368
77369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
77370   void * jresult ;
77371   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77372   Dali::Toolkit::RulerDomain *result = 0 ;
77373
77374   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77375   {
77376     try {
77377       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
77378     } catch (std::out_of_range& e) {
77379       {
77380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77381       };
77382     } catch (std::exception& e) {
77383       {
77384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77385       };
77386     } catch (Dali::DaliException e) {
77387       {
77388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77389       };
77390     } catch (...) {
77391       {
77392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77393       };
77394     }
77395   }
77396
77397   jresult = (void *)result;
77398   return jresult;
77399 }
77400
77401
77402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
77403   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77404
77405   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77406   {
77407     try {
77408       (arg1)->DisableDomain();
77409     } catch (std::out_of_range& e) {
77410       {
77411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77412       };
77413     } catch (std::exception& e) {
77414       {
77415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77416       };
77417     } catch (Dali::DaliException e) {
77418       {
77419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77420       };
77421     } catch (...) {
77422       {
77423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77424       };
77425     }
77426   }
77427
77428 }
77429
77430
77431 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
77432   float jresult ;
77433   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77434   float arg2 ;
77435   float arg3 ;
77436   float arg4 ;
77437   float result;
77438
77439   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77440   arg2 = (float)jarg2;
77441   arg3 = (float)jarg3;
77442   arg4 = (float)jarg4;
77443   {
77444     try {
77445       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
77446     } catch (std::out_of_range& e) {
77447       {
77448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77449       };
77450     } catch (std::exception& e) {
77451       {
77452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77453       };
77454     } catch (Dali::DaliException e) {
77455       {
77456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77457       };
77458     } catch (...) {
77459       {
77460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77461       };
77462     }
77463   }
77464
77465   jresult = result;
77466   return jresult;
77467 }
77468
77469
77470 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
77471   float jresult ;
77472   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77473   float arg2 ;
77474   float arg3 ;
77475   float result;
77476
77477   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77478   arg2 = (float)jarg2;
77479   arg3 = (float)jarg3;
77480   {
77481     try {
77482       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
77483     } catch (std::out_of_range& e) {
77484       {
77485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77486       };
77487     } catch (std::exception& e) {
77488       {
77489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77490       };
77491     } catch (Dali::DaliException e) {
77492       {
77493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77494       };
77495     } catch (...) {
77496       {
77497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77498       };
77499     }
77500   }
77501
77502   jresult = result;
77503   return jresult;
77504 }
77505
77506
77507 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
77508   float jresult ;
77509   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77510   float arg2 ;
77511   float result;
77512
77513   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77514   arg2 = (float)jarg2;
77515   {
77516     try {
77517       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
77518     } catch (std::out_of_range& e) {
77519       {
77520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77521       };
77522     } catch (std::exception& e) {
77523       {
77524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77525       };
77526     } catch (Dali::DaliException e) {
77527       {
77528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77529       };
77530     } catch (...) {
77531       {
77532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77533       };
77534     }
77535   }
77536
77537   jresult = result;
77538   return jresult;
77539 }
77540
77541
77542 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
77543   float jresult ;
77544   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77545   float arg2 ;
77546   float arg3 ;
77547   float arg4 ;
77548   Dali::Toolkit::ClampState *arg5 = 0 ;
77549   float result;
77550
77551   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77552   arg2 = (float)jarg2;
77553   arg3 = (float)jarg3;
77554   arg4 = (float)jarg4;
77555   arg5 = (Dali::Toolkit::ClampState *)jarg5;
77556   if (!arg5) {
77557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77558     return 0;
77559   }
77560   {
77561     try {
77562       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
77563     } catch (std::out_of_range& e) {
77564       {
77565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77566       };
77567     } catch (std::exception& e) {
77568       {
77569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77570       };
77571     } catch (Dali::DaliException e) {
77572       {
77573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77574       };
77575     } catch (...) {
77576       {
77577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77578       };
77579     }
77580   }
77581
77582   jresult = result;
77583   return jresult;
77584 }
77585
77586
77587 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
77588   float jresult ;
77589   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77590   float arg2 ;
77591   float arg3 ;
77592   float arg4 ;
77593   float arg5 ;
77594   float result;
77595
77596   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77597   arg2 = (float)jarg2;
77598   arg3 = (float)jarg3;
77599   arg4 = (float)jarg4;
77600   arg5 = (float)jarg5;
77601   {
77602     try {
77603       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
77604     } catch (std::out_of_range& e) {
77605       {
77606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77607       };
77608     } catch (std::exception& e) {
77609       {
77610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77611       };
77612     } catch (Dali::DaliException e) {
77613       {
77614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77615       };
77616     } catch (...) {
77617       {
77618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77619       };
77620     }
77621   }
77622
77623   jresult = result;
77624   return jresult;
77625 }
77626
77627
77628 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
77629   float jresult ;
77630   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77631   float arg2 ;
77632   float arg3 ;
77633   float arg4 ;
77634   float result;
77635
77636   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77637   arg2 = (float)jarg2;
77638   arg3 = (float)jarg3;
77639   arg4 = (float)jarg4;
77640   {
77641     try {
77642       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
77643     } catch (std::out_of_range& e) {
77644       {
77645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77646       };
77647     } catch (std::exception& e) {
77648       {
77649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77650       };
77651     } catch (Dali::DaliException e) {
77652       {
77653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77654       };
77655     } catch (...) {
77656       {
77657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77658       };
77659     }
77660   }
77661
77662   jresult = result;
77663   return jresult;
77664 }
77665
77666
77667 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
77668   float jresult ;
77669   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77670   float arg2 ;
77671   float arg3 ;
77672   float result;
77673
77674   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77675   arg2 = (float)jarg2;
77676   arg3 = (float)jarg3;
77677   {
77678     try {
77679       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
77680     } catch (std::out_of_range& e) {
77681       {
77682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77683       };
77684     } catch (std::exception& e) {
77685       {
77686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77687       };
77688     } catch (Dali::DaliException e) {
77689       {
77690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77691       };
77692     } catch (...) {
77693       {
77694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77695       };
77696     }
77697   }
77698
77699   jresult = result;
77700   return jresult;
77701 }
77702
77703
77704 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
77705   float jresult ;
77706   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77707   float arg2 ;
77708   float result;
77709
77710   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77711   arg2 = (float)jarg2;
77712   {
77713     try {
77714       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
77715     } catch (std::out_of_range& e) {
77716       {
77717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77718       };
77719     } catch (std::exception& e) {
77720       {
77721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77722       };
77723     } catch (Dali::DaliException e) {
77724       {
77725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77726       };
77727     } catch (...) {
77728       {
77729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77730       };
77731     }
77732   }
77733
77734   jresult = result;
77735   return jresult;
77736 }
77737
77738
77739 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
77740   float jresult ;
77741   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77742   float arg2 ;
77743   float arg3 ;
77744   float arg4 ;
77745   float arg5 ;
77746   Dali::Toolkit::ClampState *arg6 = 0 ;
77747   float result;
77748
77749   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77750   arg2 = (float)jarg2;
77751   arg3 = (float)jarg3;
77752   arg4 = (float)jarg4;
77753   arg5 = (float)jarg5;
77754   arg6 = (Dali::Toolkit::ClampState *)jarg6;
77755   if (!arg6) {
77756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77757     return 0;
77758   }
77759   {
77760     try {
77761       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
77762     } catch (std::out_of_range& e) {
77763       {
77764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77765       };
77766     } catch (std::exception& e) {
77767       {
77768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77769       };
77770     } catch (Dali::DaliException e) {
77771       {
77772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77773       };
77774     } catch (...) {
77775       {
77776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77777       };
77778     }
77779   }
77780
77781   jresult = result;
77782   return jresult;
77783 }
77784
77785
77786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
77787   void * jresult ;
77788   Dali::Toolkit::DefaultRuler *result = 0 ;
77789
77790   {
77791     try {
77792       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
77793     } catch (std::out_of_range& e) {
77794       {
77795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77796       };
77797     } catch (std::exception& e) {
77798       {
77799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77800       };
77801     } catch (Dali::DaliException e) {
77802       {
77803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77804       };
77805     } catch (...) {
77806       {
77807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77808       };
77809     }
77810   }
77811
77812   jresult = (void *)result;
77813   return jresult;
77814 }
77815
77816
77817 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
77818   float jresult ;
77819   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77820   float arg2 ;
77821   float arg3 ;
77822   float result;
77823
77824   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77825   arg2 = (float)jarg2;
77826   arg3 = (float)jarg3;
77827   {
77828     try {
77829       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
77830     } catch (std::out_of_range& e) {
77831       {
77832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77833       };
77834     } catch (std::exception& e) {
77835       {
77836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77837       };
77838     } catch (Dali::DaliException e) {
77839       {
77840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77841       };
77842     } catch (...) {
77843       {
77844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77845       };
77846     }
77847   }
77848
77849   jresult = result;
77850   return jresult;
77851 }
77852
77853
77854 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
77855   float jresult ;
77856   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77857   unsigned int arg2 ;
77858   unsigned int *arg3 = 0 ;
77859   bool arg4 ;
77860   float result;
77861
77862   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77863   arg2 = (unsigned int)jarg2;
77864   arg3 = (unsigned int *)jarg3;
77865   arg4 = jarg4 ? true : false;
77866   {
77867     try {
77868       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
77869     } catch (std::out_of_range& e) {
77870       {
77871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77872       };
77873     } catch (std::exception& e) {
77874       {
77875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77876       };
77877     } catch (Dali::DaliException e) {
77878       {
77879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77880       };
77881     } catch (...) {
77882       {
77883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77884       };
77885     }
77886   }
77887
77888   jresult = result;
77889   return jresult;
77890 }
77891
77892
77893 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
77894   unsigned int jresult ;
77895   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77896   float arg2 ;
77897   bool arg3 ;
77898   unsigned int result;
77899
77900   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77901   arg2 = (float)jarg2;
77902   arg3 = jarg3 ? true : false;
77903   {
77904     try {
77905       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
77906     } catch (std::out_of_range& e) {
77907       {
77908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77909       };
77910     } catch (std::exception& e) {
77911       {
77912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77913       };
77914     } catch (Dali::DaliException e) {
77915       {
77916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77917       };
77918     } catch (...) {
77919       {
77920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77921       };
77922     }
77923   }
77924
77925   jresult = result;
77926   return jresult;
77927 }
77928
77929
77930 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
77931   unsigned int jresult ;
77932   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77933   unsigned int result;
77934
77935   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77936   {
77937     try {
77938       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
77939     } catch (std::out_of_range& e) {
77940       {
77941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77942       };
77943     } catch (std::exception& e) {
77944       {
77945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77946       };
77947     } catch (Dali::DaliException e) {
77948       {
77949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77950       };
77951     } catch (...) {
77952       {
77953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77954       };
77955     }
77956   }
77957
77958   jresult = result;
77959   return jresult;
77960 }
77961
77962
77963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
77964   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77965
77966   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77967   {
77968     try {
77969       delete arg1;
77970     } catch (std::out_of_range& e) {
77971       {
77972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77973       };
77974     } catch (std::exception& e) {
77975       {
77976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77977       };
77978     } catch (Dali::DaliException e) {
77979       {
77980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77981       };
77982     } catch (...) {
77983       {
77984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77985       };
77986     }
77987   }
77988
77989 }
77990
77991
77992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
77993   void * jresult ;
77994   float arg1 ;
77995   Dali::Toolkit::FixedRuler *result = 0 ;
77996
77997   arg1 = (float)jarg1;
77998   {
77999     try {
78000       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
78001     } catch (std::out_of_range& e) {
78002       {
78003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78004       };
78005     } catch (std::exception& e) {
78006       {
78007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78008       };
78009     } catch (Dali::DaliException e) {
78010       {
78011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78012       };
78013     } catch (...) {
78014       {
78015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78016       };
78017     }
78018   }
78019
78020   jresult = (void *)result;
78021   return jresult;
78022 }
78023
78024
78025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
78026   void * jresult ;
78027   Dali::Toolkit::FixedRuler *result = 0 ;
78028
78029   {
78030     try {
78031       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
78032     } catch (std::out_of_range& e) {
78033       {
78034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78035       };
78036     } catch (std::exception& e) {
78037       {
78038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78039       };
78040     } catch (Dali::DaliException e) {
78041       {
78042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78043       };
78044     } catch (...) {
78045       {
78046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78047       };
78048     }
78049   }
78050
78051   jresult = (void *)result;
78052   return jresult;
78053 }
78054
78055
78056 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78057   float jresult ;
78058   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78059   float arg2 ;
78060   float arg3 ;
78061   float result;
78062
78063   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78064   arg2 = (float)jarg2;
78065   arg3 = (float)jarg3;
78066   {
78067     try {
78068       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
78069     } catch (std::out_of_range& e) {
78070       {
78071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78072       };
78073     } catch (std::exception& e) {
78074       {
78075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78076       };
78077     } catch (Dali::DaliException e) {
78078       {
78079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78080       };
78081     } catch (...) {
78082       {
78083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78084       };
78085     }
78086   }
78087
78088   jresult = result;
78089   return jresult;
78090 }
78091
78092
78093 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78094   float jresult ;
78095   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78096   unsigned int arg2 ;
78097   unsigned int *arg3 = 0 ;
78098   bool arg4 ;
78099   float result;
78100
78101   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78102   arg2 = (unsigned int)jarg2;
78103   arg3 = (unsigned int *)jarg3;
78104   arg4 = jarg4 ? true : false;
78105   {
78106     try {
78107       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78108     } catch (std::out_of_range& e) {
78109       {
78110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78111       };
78112     } catch (std::exception& e) {
78113       {
78114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78115       };
78116     } catch (Dali::DaliException e) {
78117       {
78118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78119       };
78120     } catch (...) {
78121       {
78122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78123       };
78124     }
78125   }
78126
78127   jresult = result;
78128   return jresult;
78129 }
78130
78131
78132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78133   unsigned int jresult ;
78134   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78135   float arg2 ;
78136   bool arg3 ;
78137   unsigned int result;
78138
78139   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78140   arg2 = (float)jarg2;
78141   arg3 = jarg3 ? true : false;
78142   {
78143     try {
78144       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78145     } catch (std::out_of_range& e) {
78146       {
78147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78148       };
78149     } catch (std::exception& e) {
78150       {
78151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78152       };
78153     } catch (Dali::DaliException e) {
78154       {
78155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78156       };
78157     } catch (...) {
78158       {
78159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78160       };
78161     }
78162   }
78163
78164   jresult = result;
78165   return jresult;
78166 }
78167
78168
78169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
78170   unsigned int jresult ;
78171   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78172   unsigned int result;
78173
78174   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78175   {
78176     try {
78177       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
78178     } catch (std::out_of_range& e) {
78179       {
78180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78181       };
78182     } catch (std::exception& e) {
78183       {
78184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78185       };
78186     } catch (Dali::DaliException e) {
78187       {
78188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78189       };
78190     } catch (...) {
78191       {
78192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78193       };
78194     }
78195   }
78196
78197   jresult = result;
78198   return jresult;
78199 }
78200
78201
78202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
78203   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78204
78205   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78206   {
78207     try {
78208       delete arg1;
78209     } catch (std::out_of_range& e) {
78210       {
78211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78212       };
78213     } catch (std::exception& e) {
78214       {
78215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78216       };
78217     } catch (Dali::DaliException e) {
78218       {
78219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78220       };
78221     } catch (...) {
78222       {
78223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78224       };
78225     }
78226   }
78227
78228 }
78229
78230
78231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
78232   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78233   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
78234
78235   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78236   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
78237   if (arg1) (arg1)->scale = *arg2;
78238 }
78239
78240
78241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
78242   void * jresult ;
78243   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78244   Dali::Toolkit::ClampState2D *result = 0 ;
78245
78246   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78247   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
78248   jresult = (void *)result;
78249   return jresult;
78250 }
78251
78252
78253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
78254   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78255   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
78256
78257   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78258   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
78259   if (arg1) (arg1)->position = *arg2;
78260 }
78261
78262
78263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
78264   void * jresult ;
78265   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78266   Dali::Toolkit::ClampState2D *result = 0 ;
78267
78268   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78269   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
78270   jresult = (void *)result;
78271   return jresult;
78272 }
78273
78274
78275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
78276   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78277   Dali::Toolkit::ClampState arg2 ;
78278
78279   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78280   arg2 = (Dali::Toolkit::ClampState)jarg2;
78281   if (arg1) (arg1)->rotation = arg2;
78282 }
78283
78284
78285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
78286   int jresult ;
78287   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78288   Dali::Toolkit::ClampState result;
78289
78290   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78291   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
78292   jresult = (int)result;
78293   return jresult;
78294 }
78295
78296
78297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
78298   void * jresult ;
78299   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
78300
78301   {
78302     try {
78303       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
78304     } catch (std::out_of_range& e) {
78305       {
78306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78307       };
78308     } catch (std::exception& e) {
78309       {
78310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78311       };
78312     } catch (Dali::DaliException e) {
78313       {
78314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78315       };
78316     } catch (...) {
78317       {
78318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78319       };
78320     }
78321   }
78322
78323   jresult = (void *)result;
78324   return jresult;
78325 }
78326
78327
78328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
78329   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78330
78331   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78332   {
78333     try {
78334       delete arg1;
78335     } catch (std::out_of_range& e) {
78336       {
78337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78338       };
78339     } catch (std::exception& e) {
78340       {
78341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78342       };
78343     } catch (Dali::DaliException e) {
78344       {
78345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78346       };
78347     } catch (...) {
78348       {
78349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78350       };
78351     }
78352   }
78353
78354 }
78355
78356
78357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
78358   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78359   Dali::Toolkit::SnapType arg2 ;
78360
78361   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78362   arg2 = (Dali::Toolkit::SnapType)jarg2;
78363   if (arg1) (arg1)->type = arg2;
78364 }
78365
78366
78367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
78368   int jresult ;
78369   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78370   Dali::Toolkit::SnapType result;
78371
78372   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78373   result = (Dali::Toolkit::SnapType) ((arg1)->type);
78374   jresult = (int)result;
78375   return jresult;
78376 }
78377
78378
78379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
78380   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78381   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
78382
78383   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78384   arg2 = (Dali::Vector2 *)jarg2;
78385   if (arg1) (arg1)->position = *arg2;
78386 }
78387
78388
78389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
78390   void * jresult ;
78391   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78392   Dali::Vector2 *result = 0 ;
78393
78394   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78395   result = (Dali::Vector2 *)& ((arg1)->position);
78396   jresult = (void *)result;
78397   return jresult;
78398 }
78399
78400
78401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
78402   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78403   float arg2 ;
78404
78405   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78406   arg2 = (float)jarg2;
78407   if (arg1) (arg1)->duration = arg2;
78408 }
78409
78410
78411 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
78412   float jresult ;
78413   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78414   float result;
78415
78416   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78417   result = (float) ((arg1)->duration);
78418   jresult = result;
78419   return jresult;
78420 }
78421
78422
78423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
78424   void * jresult ;
78425   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
78426
78427   {
78428     try {
78429       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
78430     } catch (std::out_of_range& e) {
78431       {
78432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78433       };
78434     } catch (std::exception& e) {
78435       {
78436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78437       };
78438     } catch (Dali::DaliException e) {
78439       {
78440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78441       };
78442     } catch (...) {
78443       {
78444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78445       };
78446     }
78447   }
78448
78449   jresult = (void *)result;
78450   return jresult;
78451 }
78452
78453
78454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
78455   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78456
78457   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78458   {
78459     try {
78460       delete arg1;
78461     } catch (std::out_of_range& e) {
78462       {
78463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78464       };
78465     } catch (std::exception& e) {
78466       {
78467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78468       };
78469     } catch (Dali::DaliException e) {
78470       {
78471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78472       };
78473     } catch (...) {
78474       {
78475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78476       };
78477     }
78478   }
78479
78480 }
78481
78482
78483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
78484   int jresult ;
78485   int result;
78486
78487   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
78488   jresult = (int)result;
78489   return jresult;
78490 }
78491
78492
78493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
78494   int jresult ;
78495   int result;
78496
78497   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
78498   jresult = (int)result;
78499   return jresult;
78500 }
78501
78502
78503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
78504   int jresult ;
78505   int result;
78506
78507   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
78508   jresult = (int)result;
78509   return jresult;
78510 }
78511
78512
78513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
78514   int jresult ;
78515   int result;
78516
78517   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
78518   jresult = (int)result;
78519   return jresult;
78520 }
78521
78522
78523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
78524   int jresult ;
78525   int result;
78526
78527   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
78528   jresult = (int)result;
78529   return jresult;
78530 }
78531
78532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
78533   int jresult ;
78534   int result;
78535
78536   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
78537   jresult = (int)result;
78538   return jresult;
78539 }
78540
78541
78542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
78543   int jresult ;
78544   int result;
78545
78546   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
78547   jresult = (int)result;
78548   return jresult;
78549 }
78550
78551
78552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
78553   int jresult ;
78554   int result;
78555
78556   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
78557   jresult = (int)result;
78558   return jresult;
78559 }
78560
78561
78562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
78563   int jresult ;
78564   int result;
78565
78566   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
78567   jresult = (int)result;
78568   return jresult;
78569 }
78570
78571
78572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
78573   int jresult ;
78574   int result;
78575
78576   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
78577   jresult = (int)result;
78578   return jresult;
78579 }
78580
78581
78582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
78583   int jresult ;
78584   int result;
78585
78586   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
78587   jresult = (int)result;
78588   return jresult;
78589 }
78590
78591
78592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
78593   int jresult ;
78594   int result;
78595
78596   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
78597   jresult = (int)result;
78598   return jresult;
78599 }
78600
78601
78602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
78603   int jresult ;
78604   int result;
78605
78606   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
78607   jresult = (int)result;
78608   return jresult;
78609 }
78610
78611
78612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
78613   int jresult ;
78614   int result;
78615
78616   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
78617   jresult = (int)result;
78618   return jresult;
78619 }
78620
78621
78622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
78623   int jresult ;
78624   int result;
78625
78626   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
78627   jresult = (int)result;
78628   return jresult;
78629 }
78630
78631
78632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
78633   int jresult ;
78634   int result;
78635
78636   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
78637   jresult = (int)result;
78638   return jresult;
78639 }
78640
78641
78642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
78643   int jresult ;
78644   int result;
78645
78646   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
78647   jresult = (int)result;
78648   return jresult;
78649 }
78650
78651
78652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
78653   int jresult ;
78654   int result;
78655
78656   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
78657   jresult = (int)result;
78658   return jresult;
78659 }
78660
78661
78662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
78663   int jresult ;
78664   int result;
78665
78666   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
78667   jresult = (int)result;
78668   return jresult;
78669 }
78670
78671
78672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
78673   int jresult ;
78674   int result;
78675
78676   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
78677   jresult = (int)result;
78678   return jresult;
78679 }
78680
78681
78682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
78683   int jresult ;
78684   int result;
78685
78686   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
78687   jresult = (int)result;
78688   return jresult;
78689 }
78690
78691
78692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
78693   int jresult ;
78694   int result;
78695
78696   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
78697   jresult = (int)result;
78698   return jresult;
78699 }
78700
78701
78702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
78703   int jresult ;
78704   int result;
78705
78706   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
78707   jresult = (int)result;
78708   return jresult;
78709 }
78710
78711
78712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
78713   int jresult ;
78714   int result;
78715
78716   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
78717   jresult = (int)result;
78718   return jresult;
78719 }
78720
78721
78722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
78723   int jresult ;
78724   int result;
78725
78726   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
78727   jresult = (int)result;
78728   return jresult;
78729 }
78730
78731
78732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
78733   int jresult ;
78734   int result;
78735
78736   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
78737   jresult = (int)result;
78738   return jresult;
78739 }
78740
78741
78742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
78743   void * jresult ;
78744   Dali::Toolkit::ScrollView::Property *result = 0 ;
78745
78746   {
78747     try {
78748       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
78749     } catch (std::out_of_range& e) {
78750       {
78751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78752       };
78753     } catch (std::exception& e) {
78754       {
78755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78756       };
78757     } catch (Dali::DaliException e) {
78758       {
78759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78760       };
78761     } catch (...) {
78762       {
78763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78764       };
78765     }
78766   }
78767
78768   jresult = (void *)result;
78769   return jresult;
78770 }
78771
78772
78773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
78774   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
78775
78776   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
78777   {
78778     try {
78779       delete arg1;
78780     } catch (std::out_of_range& e) {
78781       {
78782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78783       };
78784     } catch (std::exception& e) {
78785       {
78786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78787       };
78788     } catch (Dali::DaliException e) {
78789       {
78790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78791       };
78792     } catch (...) {
78793       {
78794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78795       };
78796     }
78797   }
78798
78799 }
78800
78801
78802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
78803   void * jresult ;
78804   Dali::Toolkit::ScrollView *result = 0 ;
78805
78806   {
78807     try {
78808       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
78809     } catch (std::out_of_range& e) {
78810       {
78811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78812       };
78813     } catch (std::exception& e) {
78814       {
78815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78816       };
78817     } catch (Dali::DaliException e) {
78818       {
78819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78820       };
78821     } catch (...) {
78822       {
78823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78824       };
78825     }
78826   }
78827
78828   jresult = (void *)result;
78829   return jresult;
78830 }
78831
78832
78833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
78834   void * jresult ;
78835   Dali::Toolkit::ScrollView *arg1 = 0 ;
78836   Dali::Toolkit::ScrollView *result = 0 ;
78837
78838   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78839   if (!arg1) {
78840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
78841     return 0;
78842   }
78843   {
78844     try {
78845       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
78846     } catch (std::out_of_range& e) {
78847       {
78848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78849       };
78850     } catch (std::exception& e) {
78851       {
78852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78853       };
78854     } catch (Dali::DaliException e) {
78855       {
78856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78857       };
78858     } catch (...) {
78859       {
78860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78861       };
78862     }
78863   }
78864
78865   jresult = (void *)result;
78866   return jresult;
78867 }
78868
78869
78870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
78871   void * jresult ;
78872   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78873   Dali::Toolkit::ScrollView *arg2 = 0 ;
78874   Dali::Toolkit::ScrollView *result = 0 ;
78875
78876   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78877   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
78878   if (!arg2) {
78879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
78880     return 0;
78881   }
78882   {
78883     try {
78884       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
78885     } catch (std::out_of_range& e) {
78886       {
78887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78888       };
78889     } catch (std::exception& e) {
78890       {
78891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78892       };
78893     } catch (Dali::DaliException e) {
78894       {
78895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78896       };
78897     } catch (...) {
78898       {
78899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78900       };
78901     }
78902   }
78903
78904   jresult = (void *)result;
78905   return jresult;
78906 }
78907
78908
78909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
78910   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78911
78912   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78913   {
78914     try {
78915       delete arg1;
78916     } catch (std::out_of_range& e) {
78917       {
78918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78919       };
78920     } catch (std::exception& e) {
78921       {
78922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78923       };
78924     } catch (Dali::DaliException e) {
78925       {
78926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78927       };
78928     } catch (...) {
78929       {
78930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78931       };
78932     }
78933   }
78934
78935 }
78936
78937
78938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
78939   void * jresult ;
78940   Dali::Toolkit::ScrollView result;
78941
78942   {
78943     try {
78944       result = Dali::Toolkit::ScrollView::New();
78945     } catch (std::out_of_range& e) {
78946       {
78947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78948       };
78949     } catch (std::exception& e) {
78950       {
78951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78952       };
78953     } catch (Dali::DaliException e) {
78954       {
78955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78956       };
78957     } catch (...) {
78958       {
78959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78960       };
78961     }
78962   }
78963
78964   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
78965   return jresult;
78966 }
78967
78968
78969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
78970   void * jresult ;
78971   Dali::BaseHandle arg1 ;
78972   Dali::BaseHandle *argp1 ;
78973   Dali::Toolkit::ScrollView result;
78974
78975   argp1 = (Dali::BaseHandle *)jarg1;
78976   if (!argp1) {
78977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78978     return 0;
78979   }
78980   arg1 = *argp1;
78981   {
78982     try {
78983       result = Dali::Toolkit::ScrollView::DownCast(arg1);
78984     } catch (std::out_of_range& e) {
78985       {
78986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78987       };
78988     } catch (std::exception& e) {
78989       {
78990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78991       };
78992     } catch (Dali::DaliException e) {
78993       {
78994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78995       };
78996     } catch (...) {
78997       {
78998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78999       };
79000     }
79001   }
79002
79003   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
79004   return jresult;
79005 }
79006
79007
79008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
79009   void * jresult ;
79010   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79011   Dali::AlphaFunction result;
79012
79013   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79014   {
79015     try {
79016       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
79017     } catch (std::out_of_range& e) {
79018       {
79019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79020       };
79021     } catch (std::exception& e) {
79022       {
79023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79024       };
79025     } catch (Dali::DaliException e) {
79026       {
79027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79028       };
79029     } catch (...) {
79030       {
79031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79032       };
79033     }
79034   }
79035
79036   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
79037   return jresult;
79038 }
79039
79040
79041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
79042   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79043   Dali::AlphaFunction arg2 ;
79044   Dali::AlphaFunction *argp2 ;
79045
79046   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79047   argp2 = (Dali::AlphaFunction *)jarg2;
79048   if (!argp2) {
79049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79050     return ;
79051   }
79052   arg2 = *argp2;
79053   {
79054     try {
79055       (arg1)->SetScrollSnapAlphaFunction(arg2);
79056     } catch (std::out_of_range& e) {
79057       {
79058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79059       };
79060     } catch (std::exception& e) {
79061       {
79062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79063       };
79064     } catch (Dali::DaliException e) {
79065       {
79066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79067       };
79068     } catch (...) {
79069       {
79070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79071       };
79072     }
79073   }
79074
79075 }
79076
79077
79078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
79079   void * jresult ;
79080   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79081   Dali::AlphaFunction result;
79082
79083   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79084   {
79085     try {
79086       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
79087     } catch (std::out_of_range& e) {
79088       {
79089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79090       };
79091     } catch (std::exception& e) {
79092       {
79093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79094       };
79095     } catch (Dali::DaliException e) {
79096       {
79097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79098       };
79099     } catch (...) {
79100       {
79101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79102       };
79103     }
79104   }
79105
79106   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
79107   return jresult;
79108 }
79109
79110
79111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
79112   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79113   Dali::AlphaFunction arg2 ;
79114   Dali::AlphaFunction *argp2 ;
79115
79116   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79117   argp2 = (Dali::AlphaFunction *)jarg2;
79118   if (!argp2) {
79119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79120     return ;
79121   }
79122   arg2 = *argp2;
79123   {
79124     try {
79125       (arg1)->SetScrollFlickAlphaFunction(arg2);
79126     } catch (std::out_of_range& e) {
79127       {
79128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79129       };
79130     } catch (std::exception& e) {
79131       {
79132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79133       };
79134     } catch (Dali::DaliException e) {
79135       {
79136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79137       };
79138     } catch (...) {
79139       {
79140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79141       };
79142     }
79143   }
79144
79145 }
79146
79147
79148 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
79149   float jresult ;
79150   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79151   float result;
79152
79153   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79154   {
79155     try {
79156       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
79157     } catch (std::out_of_range& e) {
79158       {
79159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79160       };
79161     } catch (std::exception& e) {
79162       {
79163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79164       };
79165     } catch (Dali::DaliException e) {
79166       {
79167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79168       };
79169     } catch (...) {
79170       {
79171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79172       };
79173     }
79174   }
79175
79176   jresult = result;
79177   return jresult;
79178 }
79179
79180
79181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
79182   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79183   float arg2 ;
79184
79185   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79186   arg2 = (float)jarg2;
79187   {
79188     try {
79189       (arg1)->SetScrollSnapDuration(arg2);
79190     } catch (std::out_of_range& e) {
79191       {
79192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79193       };
79194     } catch (std::exception& e) {
79195       {
79196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79197       };
79198     } catch (Dali::DaliException e) {
79199       {
79200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79201       };
79202     } catch (...) {
79203       {
79204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79205       };
79206     }
79207   }
79208
79209 }
79210
79211
79212 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
79213   float jresult ;
79214   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79215   float result;
79216
79217   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79218   {
79219     try {
79220       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
79221     } catch (std::out_of_range& e) {
79222       {
79223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79224       };
79225     } catch (std::exception& e) {
79226       {
79227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79228       };
79229     } catch (Dali::DaliException e) {
79230       {
79231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79232       };
79233     } catch (...) {
79234       {
79235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79236       };
79237     }
79238   }
79239
79240   jresult = result;
79241   return jresult;
79242 }
79243
79244
79245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
79246   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79247   float arg2 ;
79248
79249   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79250   arg2 = (float)jarg2;
79251   {
79252     try {
79253       (arg1)->SetScrollFlickDuration(arg2);
79254     } catch (std::out_of_range& e) {
79255       {
79256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79257       };
79258     } catch (std::exception& e) {
79259       {
79260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79261       };
79262     } catch (Dali::DaliException e) {
79263       {
79264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79265       };
79266     } catch (...) {
79267       {
79268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79269       };
79270     }
79271   }
79272
79273 }
79274
79275
79276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
79277   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79278   Dali::Toolkit::RulerPtr arg2 ;
79279   Dali::Toolkit::RulerPtr *argp2 ;
79280
79281   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79282   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
79283   if (!argp2) {
79284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
79285     return ;
79286   }
79287   arg2 = *argp2;
79288   {
79289     try {
79290       (arg1)->SetRulerX(arg2);
79291     } catch (std::out_of_range& e) {
79292       {
79293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79294       };
79295     } catch (std::exception& e) {
79296       {
79297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79298       };
79299     } catch (Dali::DaliException e) {
79300       {
79301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79302       };
79303     } catch (...) {
79304       {
79305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79306       };
79307     }
79308   }
79309
79310 }
79311
79312
79313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
79314   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79315   Dali::Toolkit::RulerPtr arg2 ;
79316   Dali::Toolkit::RulerPtr *argp2 ;
79317
79318   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79319   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
79320   if (!argp2) {
79321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
79322     return ;
79323   }
79324   arg2 = *argp2;
79325   {
79326     try {
79327       (arg1)->SetRulerY(arg2);
79328     } catch (std::out_of_range& e) {
79329       {
79330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79331       };
79332     } catch (std::exception& e) {
79333       {
79334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79335       };
79336     } catch (Dali::DaliException e) {
79337       {
79338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79339       };
79340     } catch (...) {
79341       {
79342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79343       };
79344     }
79345   }
79346
79347 }
79348
79349
79350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
79351   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79352   bool arg2 ;
79353
79354   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79355   arg2 = jarg2 ? true : false;
79356   {
79357     try {
79358       (arg1)->SetScrollSensitive(arg2);
79359     } catch (std::out_of_range& e) {
79360       {
79361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79362       };
79363     } catch (std::exception& e) {
79364       {
79365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79366       };
79367     } catch (Dali::DaliException e) {
79368       {
79369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79370       };
79371     } catch (...) {
79372       {
79373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79374       };
79375     }
79376   }
79377
79378 }
79379
79380
79381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
79382   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79383   float arg2 ;
79384   float arg3 ;
79385
79386   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79387   arg2 = (float)jarg2;
79388   arg3 = (float)jarg3;
79389   {
79390     try {
79391       (arg1)->SetMaxOvershoot(arg2,arg3);
79392     } catch (std::out_of_range& e) {
79393       {
79394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79395       };
79396     } catch (std::exception& e) {
79397       {
79398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79399       };
79400     } catch (Dali::DaliException e) {
79401       {
79402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79403       };
79404     } catch (...) {
79405       {
79406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79407       };
79408     }
79409   }
79410
79411 }
79412
79413
79414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
79415   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79416   Dali::AlphaFunction arg2 ;
79417   Dali::AlphaFunction *argp2 ;
79418
79419   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79420   argp2 = (Dali::AlphaFunction *)jarg2;
79421   if (!argp2) {
79422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79423     return ;
79424   }
79425   arg2 = *argp2;
79426   {
79427     try {
79428       (arg1)->SetSnapOvershootAlphaFunction(arg2);
79429     } catch (std::out_of_range& e) {
79430       {
79431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79432       };
79433     } catch (std::exception& e) {
79434       {
79435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79436       };
79437     } catch (Dali::DaliException e) {
79438       {
79439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79440       };
79441     } catch (...) {
79442       {
79443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79444       };
79445     }
79446   }
79447
79448 }
79449
79450
79451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
79452   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79453   float arg2 ;
79454
79455   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79456   arg2 = (float)jarg2;
79457   {
79458     try {
79459       (arg1)->SetSnapOvershootDuration(arg2);
79460     } catch (std::out_of_range& e) {
79461       {
79462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79463       };
79464     } catch (std::exception& e) {
79465       {
79466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79467       };
79468     } catch (Dali::DaliException e) {
79469       {
79470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79471       };
79472     } catch (...) {
79473       {
79474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79475       };
79476     }
79477   }
79478
79479 }
79480
79481
79482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
79483   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79484   bool arg2 ;
79485
79486   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79487   arg2 = jarg2 ? true : false;
79488   {
79489     try {
79490       (arg1)->SetActorAutoSnap(arg2);
79491     } catch (std::out_of_range& e) {
79492       {
79493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79494       };
79495     } catch (std::exception& e) {
79496       {
79497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79498       };
79499     } catch (Dali::DaliException e) {
79500       {
79501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79502       };
79503     } catch (...) {
79504       {
79505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79506       };
79507     }
79508   }
79509
79510 }
79511
79512
79513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
79514   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79515   bool arg2 ;
79516
79517   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79518   arg2 = jarg2 ? true : false;
79519   {
79520     try {
79521       (arg1)->SetWrapMode(arg2);
79522     } catch (std::out_of_range& e) {
79523       {
79524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79525       };
79526     } catch (std::exception& e) {
79527       {
79528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79529       };
79530     } catch (Dali::DaliException e) {
79531       {
79532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79533       };
79534     } catch (...) {
79535       {
79536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79537       };
79538     }
79539   }
79540
79541 }
79542
79543
79544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
79545   int jresult ;
79546   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79547   int result;
79548
79549   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79550   {
79551     try {
79552       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
79553     } catch (std::out_of_range& e) {
79554       {
79555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79556       };
79557     } catch (std::exception& e) {
79558       {
79559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79560       };
79561     } catch (Dali::DaliException e) {
79562       {
79563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79564       };
79565     } catch (...) {
79566       {
79567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79568       };
79569     }
79570   }
79571
79572   jresult = result;
79573   return jresult;
79574 }
79575
79576
79577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
79578   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79579   int arg2 ;
79580
79581   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79582   arg2 = (int)jarg2;
79583   {
79584     try {
79585       (arg1)->SetScrollUpdateDistance(arg2);
79586     } catch (std::out_of_range& e) {
79587       {
79588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79589       };
79590     } catch (std::exception& e) {
79591       {
79592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79593       };
79594     } catch (Dali::DaliException e) {
79595       {
79596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79597       };
79598     } catch (...) {
79599       {
79600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79601       };
79602     }
79603   }
79604
79605 }
79606
79607
79608 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
79609   unsigned int jresult ;
79610   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79611   bool result;
79612
79613   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79614   {
79615     try {
79616       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
79617     } catch (std::out_of_range& e) {
79618       {
79619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79620       };
79621     } catch (std::exception& e) {
79622       {
79623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79624       };
79625     } catch (Dali::DaliException e) {
79626       {
79627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79628       };
79629     } catch (...) {
79630       {
79631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79632       };
79633     }
79634   }
79635
79636   jresult = result;
79637   return jresult;
79638 }
79639
79640
79641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
79642   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79643   bool arg2 ;
79644
79645   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79646   arg2 = jarg2 ? true : false;
79647   {
79648     try {
79649       (arg1)->SetAxisAutoLock(arg2);
79650     } catch (std::out_of_range& e) {
79651       {
79652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79653       };
79654     } catch (std::exception& e) {
79655       {
79656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79657       };
79658     } catch (Dali::DaliException e) {
79659       {
79660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79661       };
79662     } catch (...) {
79663       {
79664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79665       };
79666     }
79667   }
79668
79669 }
79670
79671
79672 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
79673   float jresult ;
79674   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79675   float result;
79676
79677   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79678   {
79679     try {
79680       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
79681     } catch (std::out_of_range& e) {
79682       {
79683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79684       };
79685     } catch (std::exception& e) {
79686       {
79687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79688       };
79689     } catch (Dali::DaliException e) {
79690       {
79691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79692       };
79693     } catch (...) {
79694       {
79695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79696       };
79697     }
79698   }
79699
79700   jresult = result;
79701   return jresult;
79702 }
79703
79704
79705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
79706   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79707   float arg2 ;
79708
79709   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79710   arg2 = (float)jarg2;
79711   {
79712     try {
79713       (arg1)->SetAxisAutoLockGradient(arg2);
79714     } catch (std::out_of_range& e) {
79715       {
79716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79717       };
79718     } catch (std::exception& e) {
79719       {
79720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79721       };
79722     } catch (Dali::DaliException e) {
79723       {
79724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79725       };
79726     } catch (...) {
79727       {
79728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79729       };
79730     }
79731   }
79732
79733 }
79734
79735
79736 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
79737   float jresult ;
79738   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79739   float result;
79740
79741   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79742   {
79743     try {
79744       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
79745     } catch (std::out_of_range& e) {
79746       {
79747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79748       };
79749     } catch (std::exception& e) {
79750       {
79751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79752       };
79753     } catch (Dali::DaliException e) {
79754       {
79755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79756       };
79757     } catch (...) {
79758       {
79759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79760       };
79761     }
79762   }
79763
79764   jresult = result;
79765   return jresult;
79766 }
79767
79768
79769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
79770   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79771   float arg2 ;
79772
79773   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79774   arg2 = (float)jarg2;
79775   {
79776     try {
79777       (arg1)->SetFrictionCoefficient(arg2);
79778     } catch (std::out_of_range& e) {
79779       {
79780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79781       };
79782     } catch (std::exception& e) {
79783       {
79784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79785       };
79786     } catch (Dali::DaliException e) {
79787       {
79788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79789       };
79790     } catch (...) {
79791       {
79792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79793       };
79794     }
79795   }
79796
79797 }
79798
79799
79800 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
79801   float jresult ;
79802   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79803   float result;
79804
79805   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79806   {
79807     try {
79808       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
79809     } catch (std::out_of_range& e) {
79810       {
79811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79812       };
79813     } catch (std::exception& e) {
79814       {
79815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79816       };
79817     } catch (Dali::DaliException e) {
79818       {
79819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79820       };
79821     } catch (...) {
79822       {
79823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79824       };
79825     }
79826   }
79827
79828   jresult = result;
79829   return jresult;
79830 }
79831
79832
79833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
79834   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79835   float arg2 ;
79836
79837   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79838   arg2 = (float)jarg2;
79839   {
79840     try {
79841       (arg1)->SetFlickSpeedCoefficient(arg2);
79842     } catch (std::out_of_range& e) {
79843       {
79844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79845       };
79846     } catch (std::exception& e) {
79847       {
79848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79849       };
79850     } catch (Dali::DaliException e) {
79851       {
79852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79853       };
79854     } catch (...) {
79855       {
79856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79857       };
79858     }
79859   }
79860
79861 }
79862
79863
79864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
79865   void * jresult ;
79866   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79867   Dali::Vector2 result;
79868
79869   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79870   {
79871     try {
79872       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
79873     } catch (std::out_of_range& e) {
79874       {
79875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79876       };
79877     } catch (std::exception& e) {
79878       {
79879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79880       };
79881     } catch (Dali::DaliException e) {
79882       {
79883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79884       };
79885     } catch (...) {
79886       {
79887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79888       };
79889     }
79890   }
79891
79892   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79893   return jresult;
79894 }
79895
79896
79897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
79898   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79899   Dali::Vector2 *arg2 = 0 ;
79900
79901   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79902   arg2 = (Dali::Vector2 *)jarg2;
79903   if (!arg2) {
79904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
79905     return ;
79906   }
79907   {
79908     try {
79909       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
79910     } catch (std::out_of_range& e) {
79911       {
79912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79913       };
79914     } catch (std::exception& e) {
79915       {
79916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79917       };
79918     } catch (Dali::DaliException e) {
79919       {
79920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79921       };
79922     } catch (...) {
79923       {
79924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79925       };
79926     }
79927   }
79928
79929 }
79930
79931
79932 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
79933   float jresult ;
79934   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79935   float result;
79936
79937   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79938   {
79939     try {
79940       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
79941     } catch (std::out_of_range& e) {
79942       {
79943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79944       };
79945     } catch (std::exception& e) {
79946       {
79947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79948       };
79949     } catch (Dali::DaliException e) {
79950       {
79951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79952       };
79953     } catch (...) {
79954       {
79955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79956       };
79957     }
79958   }
79959
79960   jresult = result;
79961   return jresult;
79962 }
79963
79964
79965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
79966   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79967   float arg2 ;
79968
79969   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79970   arg2 = (float)jarg2;
79971   {
79972     try {
79973       (arg1)->SetMinimumSpeedForFlick(arg2);
79974     } catch (std::out_of_range& e) {
79975       {
79976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79977       };
79978     } catch (std::exception& e) {
79979       {
79980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79981       };
79982     } catch (Dali::DaliException e) {
79983       {
79984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79985       };
79986     } catch (...) {
79987       {
79988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79989       };
79990     }
79991   }
79992
79993 }
79994
79995
79996 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
79997   float jresult ;
79998   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79999   float result;
80000
80001   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80002   {
80003     try {
80004       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
80005     } catch (std::out_of_range& e) {
80006       {
80007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80008       };
80009     } catch (std::exception& e) {
80010       {
80011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80012       };
80013     } catch (Dali::DaliException e) {
80014       {
80015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80016       };
80017     } catch (...) {
80018       {
80019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80020       };
80021     }
80022   }
80023
80024   jresult = result;
80025   return jresult;
80026 }
80027
80028
80029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
80030   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80031   float arg2 ;
80032
80033   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80034   arg2 = (float)jarg2;
80035   {
80036     try {
80037       (arg1)->SetMaxFlickSpeed(arg2);
80038     } catch (std::out_of_range& e) {
80039       {
80040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80041       };
80042     } catch (std::exception& e) {
80043       {
80044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80045       };
80046     } catch (Dali::DaliException e) {
80047       {
80048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80049       };
80050     } catch (...) {
80051       {
80052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80053       };
80054     }
80055   }
80056
80057 }
80058
80059
80060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
80061   void * jresult ;
80062   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80063   Dali::Vector2 result;
80064
80065   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80066   {
80067     try {
80068       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
80069     } catch (std::out_of_range& e) {
80070       {
80071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80072       };
80073     } catch (std::exception& e) {
80074       {
80075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80076       };
80077     } catch (Dali::DaliException e) {
80078       {
80079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80080       };
80081     } catch (...) {
80082       {
80083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80084       };
80085     }
80086   }
80087
80088   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80089   return jresult;
80090 }
80091
80092
80093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
80094   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80095   Dali::Vector2 arg2 ;
80096   Dali::Vector2 *argp2 ;
80097
80098   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80099   argp2 = (Dali::Vector2 *)jarg2;
80100   if (!argp2) {
80101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
80102     return ;
80103   }
80104   arg2 = *argp2;
80105   {
80106     try {
80107       (arg1)->SetWheelScrollDistanceStep(arg2);
80108     } catch (std::out_of_range& e) {
80109       {
80110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80111       };
80112     } catch (std::exception& e) {
80113       {
80114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80115       };
80116     } catch (Dali::DaliException e) {
80117       {
80118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80119       };
80120     } catch (...) {
80121       {
80122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80123       };
80124     }
80125   }
80126
80127 }
80128
80129
80130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
80131   void * jresult ;
80132   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80133   Dali::Vector2 result;
80134
80135   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80136   {
80137     try {
80138       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
80139     } catch (std::out_of_range& e) {
80140       {
80141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80142       };
80143     } catch (std::exception& e) {
80144       {
80145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80146       };
80147     } catch (Dali::DaliException e) {
80148       {
80149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80150       };
80151     } catch (...) {
80152       {
80153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80154       };
80155     }
80156   }
80157
80158   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80159   return jresult;
80160 }
80161
80162
80163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
80164   unsigned int jresult ;
80165   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80166   unsigned int result;
80167
80168   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80169   {
80170     try {
80171       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
80172     } catch (std::out_of_range& e) {
80173       {
80174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80175       };
80176     } catch (std::exception& e) {
80177       {
80178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80179       };
80180     } catch (Dali::DaliException e) {
80181       {
80182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80183       };
80184     } catch (...) {
80185       {
80186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80187       };
80188     }
80189   }
80190
80191   jresult = result;
80192   return jresult;
80193 }
80194
80195
80196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
80197   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80198   Dali::Vector2 *arg2 = 0 ;
80199
80200   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80201   arg2 = (Dali::Vector2 *)jarg2;
80202   if (!arg2) {
80203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80204     return ;
80205   }
80206   {
80207     try {
80208       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
80209     } catch (std::out_of_range& e) {
80210       {
80211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80212       };
80213     } catch (std::exception& e) {
80214       {
80215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80216       };
80217     } catch (Dali::DaliException e) {
80218       {
80219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80220       };
80221     } catch (...) {
80222       {
80223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80224       };
80225     }
80226   }
80227
80228 }
80229
80230
80231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
80232   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80233   Dali::Vector2 *arg2 = 0 ;
80234   float arg3 ;
80235
80236   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80237   arg2 = (Dali::Vector2 *)jarg2;
80238   if (!arg2) {
80239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80240     return ;
80241   }
80242   arg3 = (float)jarg3;
80243   {
80244     try {
80245       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
80246     } catch (std::out_of_range& e) {
80247       {
80248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80249       };
80250     } catch (std::exception& e) {
80251       {
80252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80253       };
80254     } catch (Dali::DaliException e) {
80255       {
80256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80257       };
80258     } catch (...) {
80259       {
80260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80261       };
80262     }
80263   }
80264
80265 }
80266
80267
80268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
80269   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80270   Dali::Vector2 *arg2 = 0 ;
80271   float arg3 ;
80272   Dali::AlphaFunction arg4 ;
80273   Dali::AlphaFunction *argp4 ;
80274
80275   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80276   arg2 = (Dali::Vector2 *)jarg2;
80277   if (!arg2) {
80278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80279     return ;
80280   }
80281   arg3 = (float)jarg3;
80282   argp4 = (Dali::AlphaFunction *)jarg4;
80283   if (!argp4) {
80284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80285     return ;
80286   }
80287   arg4 = *argp4;
80288   {
80289     try {
80290       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
80291     } catch (std::out_of_range& e) {
80292       {
80293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80294       };
80295     } catch (std::exception& e) {
80296       {
80297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80298       };
80299     } catch (Dali::DaliException e) {
80300       {
80301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80302       };
80303     } catch (...) {
80304       {
80305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80306       };
80307     }
80308   }
80309
80310 }
80311
80312
80313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
80314   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80315   Dali::Vector2 *arg2 = 0 ;
80316   float arg3 ;
80317   Dali::Toolkit::DirectionBias arg4 ;
80318   Dali::Toolkit::DirectionBias arg5 ;
80319
80320   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80321   arg2 = (Dali::Vector2 *)jarg2;
80322   if (!arg2) {
80323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80324     return ;
80325   }
80326   arg3 = (float)jarg3;
80327   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
80328   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
80329   {
80330     try {
80331       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
80332     } catch (std::out_of_range& e) {
80333       {
80334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80335       };
80336     } catch (std::exception& e) {
80337       {
80338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80339       };
80340     } catch (Dali::DaliException e) {
80341       {
80342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80343       };
80344     } catch (...) {
80345       {
80346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80347       };
80348     }
80349   }
80350
80351 }
80352
80353
80354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
80355   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80356   Dali::Vector2 *arg2 = 0 ;
80357   float arg3 ;
80358   Dali::AlphaFunction arg4 ;
80359   Dali::Toolkit::DirectionBias arg5 ;
80360   Dali::Toolkit::DirectionBias arg6 ;
80361   Dali::AlphaFunction *argp4 ;
80362
80363   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80364   arg2 = (Dali::Vector2 *)jarg2;
80365   if (!arg2) {
80366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80367     return ;
80368   }
80369   arg3 = (float)jarg3;
80370   argp4 = (Dali::AlphaFunction *)jarg4;
80371   if (!argp4) {
80372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80373     return ;
80374   }
80375   arg4 = *argp4;
80376   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
80377   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
80378   {
80379     try {
80380       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
80381     } catch (std::out_of_range& e) {
80382       {
80383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80384       };
80385     } catch (std::exception& e) {
80386       {
80387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80388       };
80389     } catch (Dali::DaliException e) {
80390       {
80391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80392       };
80393     } catch (...) {
80394       {
80395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80396       };
80397     }
80398   }
80399
80400 }
80401
80402
80403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
80404   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80405   unsigned int arg2 ;
80406
80407   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80408   arg2 = (unsigned int)jarg2;
80409   {
80410     try {
80411       (arg1)->ScrollTo(arg2);
80412     } catch (std::out_of_range& e) {
80413       {
80414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80415       };
80416     } catch (std::exception& e) {
80417       {
80418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80419       };
80420     } catch (Dali::DaliException e) {
80421       {
80422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80423       };
80424     } catch (...) {
80425       {
80426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80427       };
80428     }
80429   }
80430
80431 }
80432
80433
80434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
80435   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80436   unsigned int arg2 ;
80437   float arg3 ;
80438
80439   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80440   arg2 = (unsigned int)jarg2;
80441   arg3 = (float)jarg3;
80442   {
80443     try {
80444       (arg1)->ScrollTo(arg2,arg3);
80445     } catch (std::out_of_range& e) {
80446       {
80447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80448       };
80449     } catch (std::exception& e) {
80450       {
80451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80452       };
80453     } catch (Dali::DaliException e) {
80454       {
80455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80456       };
80457     } catch (...) {
80458       {
80459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80460       };
80461     }
80462   }
80463
80464 }
80465
80466
80467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
80468   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80469   unsigned int arg2 ;
80470   float arg3 ;
80471   Dali::Toolkit::DirectionBias arg4 ;
80472
80473   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80474   arg2 = (unsigned int)jarg2;
80475   arg3 = (float)jarg3;
80476   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
80477   {
80478     try {
80479       (arg1)->ScrollTo(arg2,arg3,arg4);
80480     } catch (std::out_of_range& e) {
80481       {
80482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80483       };
80484     } catch (std::exception& e) {
80485       {
80486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80487       };
80488     } catch (Dali::DaliException e) {
80489       {
80490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80491       };
80492     } catch (...) {
80493       {
80494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80495       };
80496     }
80497   }
80498
80499 }
80500
80501
80502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
80503   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80504   Dali::Actor *arg2 = 0 ;
80505
80506   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80507   arg2 = (Dali::Actor *)jarg2;
80508   if (!arg2) {
80509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
80510     return ;
80511   }
80512   {
80513     try {
80514       (arg1)->ScrollTo(*arg2);
80515     } catch (std::out_of_range& e) {
80516       {
80517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80518       };
80519     } catch (std::exception& e) {
80520       {
80521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80522       };
80523     } catch (Dali::DaliException e) {
80524       {
80525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80526       };
80527     } catch (...) {
80528       {
80529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80530       };
80531     }
80532   }
80533
80534 }
80535
80536
80537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
80538   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80539   Dali::Actor *arg2 = 0 ;
80540   float arg3 ;
80541
80542   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80543   arg2 = (Dali::Actor *)jarg2;
80544   if (!arg2) {
80545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
80546     return ;
80547   }
80548   arg3 = (float)jarg3;
80549   {
80550     try {
80551       (arg1)->ScrollTo(*arg2,arg3);
80552     } catch (std::out_of_range& e) {
80553       {
80554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80555       };
80556     } catch (std::exception& e) {
80557       {
80558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80559       };
80560     } catch (Dali::DaliException e) {
80561       {
80562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80563       };
80564     } catch (...) {
80565       {
80566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80567       };
80568     }
80569   }
80570
80571 }
80572
80573
80574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
80575   unsigned int jresult ;
80576   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80577   bool result;
80578
80579   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80580   {
80581     try {
80582       result = (bool)(arg1)->ScrollToSnapPoint();
80583     } catch (std::out_of_range& e) {
80584       {
80585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80586       };
80587     } catch (std::exception& e) {
80588       {
80589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80590       };
80591     } catch (Dali::DaliException e) {
80592       {
80593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80594       };
80595     } catch (...) {
80596       {
80597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80598       };
80599     }
80600   }
80601
80602   jresult = result;
80603   return jresult;
80604 }
80605
80606
80607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
80608   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80609   Dali::Constraint arg2 ;
80610   Dali::Constraint *argp2 ;
80611
80612   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80613   argp2 = (Dali::Constraint *)jarg2;
80614   if (!argp2) {
80615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
80616     return ;
80617   }
80618   arg2 = *argp2;
80619   {
80620     try {
80621       (arg1)->ApplyConstraintToChildren(arg2);
80622     } catch (std::out_of_range& e) {
80623       {
80624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80625       };
80626     } catch (std::exception& e) {
80627       {
80628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80629       };
80630     } catch (Dali::DaliException e) {
80631       {
80632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80633       };
80634     } catch (...) {
80635       {
80636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80637       };
80638     }
80639   }
80640
80641 }
80642
80643
80644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
80645   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80646
80647   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80648   {
80649     try {
80650       (arg1)->RemoveConstraintsFromChildren();
80651     } catch (std::out_of_range& e) {
80652       {
80653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80654       };
80655     } catch (std::exception& e) {
80656       {
80657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80658       };
80659     } catch (Dali::DaliException e) {
80660       {
80661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80662       };
80663     } catch (...) {
80664       {
80665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80666       };
80667     }
80668   }
80669
80670 }
80671
80672
80673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
80674   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80675   Dali::Toolkit::ScrollViewEffect arg2 ;
80676   Dali::Toolkit::ScrollViewEffect *argp2 ;
80677
80678   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80679   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
80680   if (!argp2) {
80681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
80682     return ;
80683   }
80684   arg2 = *argp2;
80685   {
80686     try {
80687       (arg1)->ApplyEffect(arg2);
80688     } catch (std::out_of_range& e) {
80689       {
80690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80691       };
80692     } catch (std::exception& e) {
80693       {
80694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80695       };
80696     } catch (Dali::DaliException e) {
80697       {
80698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80699       };
80700     } catch (...) {
80701       {
80702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80703       };
80704     }
80705   }
80706
80707 }
80708
80709
80710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
80711   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80712   Dali::Toolkit::ScrollViewEffect arg2 ;
80713   Dali::Toolkit::ScrollViewEffect *argp2 ;
80714
80715   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80716   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
80717   if (!argp2) {
80718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
80719     return ;
80720   }
80721   arg2 = *argp2;
80722   {
80723     try {
80724       (arg1)->RemoveEffect(arg2);
80725     } catch (std::out_of_range& e) {
80726       {
80727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80728       };
80729     } catch (std::exception& e) {
80730       {
80731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80732       };
80733     } catch (Dali::DaliException e) {
80734       {
80735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80736       };
80737     } catch (...) {
80738       {
80739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80740       };
80741     }
80742   }
80743
80744 }
80745
80746
80747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
80748   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80749
80750   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80751   {
80752     try {
80753       (arg1)->RemoveAllEffects();
80754     } catch (std::out_of_range& e) {
80755       {
80756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80757       };
80758     } catch (std::exception& e) {
80759       {
80760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80761       };
80762     } catch (Dali::DaliException e) {
80763       {
80764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80765       };
80766     } catch (...) {
80767       {
80768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80769       };
80770     }
80771   }
80772
80773 }
80774
80775
80776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
80777   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80778   Dali::Actor arg2 ;
80779   Dali::Actor *argp2 ;
80780
80781   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80782   argp2 = (Dali::Actor *)jarg2;
80783   if (!argp2) {
80784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80785     return ;
80786   }
80787   arg2 = *argp2;
80788   {
80789     try {
80790       (arg1)->BindActor(arg2);
80791     } catch (std::out_of_range& e) {
80792       {
80793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80794       };
80795     } catch (std::exception& e) {
80796       {
80797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80798       };
80799     } catch (Dali::DaliException e) {
80800       {
80801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80802       };
80803     } catch (...) {
80804       {
80805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80806       };
80807     }
80808   }
80809
80810 }
80811
80812
80813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
80814   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80815   Dali::Actor arg2 ;
80816   Dali::Actor *argp2 ;
80817
80818   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80819   argp2 = (Dali::Actor *)jarg2;
80820   if (!argp2) {
80821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80822     return ;
80823   }
80824   arg2 = *argp2;
80825   {
80826     try {
80827       (arg1)->UnbindActor(arg2);
80828     } catch (std::out_of_range& e) {
80829       {
80830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80831       };
80832     } catch (std::exception& e) {
80833       {
80834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80835       };
80836     } catch (Dali::DaliException e) {
80837       {
80838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80839       };
80840     } catch (...) {
80841       {
80842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80843       };
80844     }
80845   }
80846
80847 }
80848
80849
80850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
80851   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80852   Dali::Radian arg2 ;
80853   Dali::Radian arg3 ;
80854   Dali::Radian *argp2 ;
80855   Dali::Radian *argp3 ;
80856
80857   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80858   argp2 = (Dali::Radian *)jarg2;
80859   if (!argp2) {
80860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80861     return ;
80862   }
80863   arg2 = *argp2;
80864   argp3 = (Dali::Radian *)jarg3;
80865   if (!argp3) {
80866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80867     return ;
80868   }
80869   arg3 = *argp3;
80870   {
80871     try {
80872       (arg1)->SetScrollingDirection(arg2,arg3);
80873     } catch (std::out_of_range& e) {
80874       {
80875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80876       };
80877     } catch (std::exception& e) {
80878       {
80879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80880       };
80881     } catch (Dali::DaliException e) {
80882       {
80883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80884       };
80885     } catch (...) {
80886       {
80887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80888       };
80889     }
80890   }
80891
80892 }
80893
80894
80895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
80896   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80897   Dali::Radian arg2 ;
80898   Dali::Radian *argp2 ;
80899
80900   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80901   argp2 = (Dali::Radian *)jarg2;
80902   if (!argp2) {
80903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80904     return ;
80905   }
80906   arg2 = *argp2;
80907   {
80908     try {
80909       (arg1)->SetScrollingDirection(arg2);
80910     } catch (std::out_of_range& e) {
80911       {
80912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80913       };
80914     } catch (std::exception& e) {
80915       {
80916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80917       };
80918     } catch (Dali::DaliException e) {
80919       {
80920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80921       };
80922     } catch (...) {
80923       {
80924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80925       };
80926     }
80927   }
80928
80929 }
80930
80931
80932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
80933   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80934   Dali::Radian arg2 ;
80935   Dali::Radian *argp2 ;
80936
80937   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80938   argp2 = (Dali::Radian *)jarg2;
80939   if (!argp2) {
80940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80941     return ;
80942   }
80943   arg2 = *argp2;
80944   {
80945     try {
80946       (arg1)->RemoveScrollingDirection(arg2);
80947     } catch (std::out_of_range& e) {
80948       {
80949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80950       };
80951     } catch (std::exception& e) {
80952       {
80953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80954       };
80955     } catch (Dali::DaliException e) {
80956       {
80957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80958       };
80959     } catch (...) {
80960       {
80961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80962       };
80963     }
80964   }
80965
80966 }
80967
80968
80969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
80970   void * jresult ;
80971   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80972   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
80973
80974   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80975   {
80976     try {
80977       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
80978     } catch (std::out_of_range& e) {
80979       {
80980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80981       };
80982     } catch (std::exception& e) {
80983       {
80984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80985       };
80986     } catch (Dali::DaliException e) {
80987       {
80988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80989       };
80990     } catch (...) {
80991       {
80992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80993       };
80994     }
80995   }
80996
80997   jresult = (void *)result;
80998   return jresult;
80999 }
81000
81001
81002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
81003   int jresult ;
81004   int result;
81005
81006   result = (int)Dali::Toolkit::TableView::Property::ROWS;
81007   jresult = (int)result;
81008   return jresult;
81009 }
81010
81011
81012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
81013   int jresult ;
81014   int result;
81015
81016   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
81017   jresult = (int)result;
81018   return jresult;
81019 }
81020
81021
81022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
81023   int jresult ;
81024   int result;
81025
81026   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
81027   jresult = (int)result;
81028   return jresult;
81029 }
81030
81031
81032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
81033   int jresult ;
81034   int result;
81035
81036   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
81037   jresult = (int)result;
81038   return jresult;
81039 }
81040
81041
81042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
81043   int jresult ;
81044   int result;
81045
81046   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
81047   jresult = (int)result;
81048   return jresult;
81049 }
81050
81051
81052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
81053   void * jresult ;
81054   Dali::Toolkit::TableView::Property *result = 0 ;
81055
81056   {
81057     try {
81058       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
81059     } catch (std::out_of_range& e) {
81060       {
81061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81062       };
81063     } catch (std::exception& e) {
81064       {
81065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81066       };
81067     } catch (Dali::DaliException e) {
81068       {
81069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81070       };
81071     } catch (...) {
81072       {
81073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81074       };
81075     }
81076   }
81077
81078   jresult = (void *)result;
81079   return jresult;
81080 }
81081
81082
81083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
81084   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
81085
81086   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
81087   {
81088     try {
81089       delete arg1;
81090     } catch (std::out_of_range& e) {
81091       {
81092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81093       };
81094     } catch (std::exception& e) {
81095       {
81096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81097       };
81098     } catch (Dali::DaliException e) {
81099       {
81100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81101       };
81102     } catch (...) {
81103       {
81104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81105       };
81106     }
81107   }
81108
81109 }
81110
81111
81112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
81113   int jresult ;
81114   int result;
81115
81116   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
81117   jresult = (int)result;
81118   return jresult;
81119 }
81120
81121
81122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
81123   int jresult ;
81124   int result;
81125
81126   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
81127   jresult = (int)result;
81128   return jresult;
81129 }
81130
81131
81132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
81133   int jresult ;
81134   int result;
81135
81136   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
81137   jresult = (int)result;
81138   return jresult;
81139 }
81140
81141
81142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
81143   int jresult ;
81144   int result;
81145
81146   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
81147   jresult = (int)result;
81148   return jresult;
81149 }
81150
81151
81152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
81153   int jresult ;
81154   int result;
81155
81156   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
81157   jresult = (int)result;
81158   return jresult;
81159 }
81160
81161
81162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
81163   void * jresult ;
81164   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
81165
81166   {
81167     try {
81168       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
81169     } catch (std::out_of_range& e) {
81170       {
81171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81172       };
81173     } catch (std::exception& e) {
81174       {
81175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81176       };
81177     } catch (Dali::DaliException e) {
81178       {
81179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81180       };
81181     } catch (...) {
81182       {
81183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81184       };
81185     }
81186   }
81187
81188   jresult = (void *)result;
81189   return jresult;
81190 }
81191
81192
81193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
81194   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
81195
81196   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
81197   {
81198     try {
81199       delete arg1;
81200     } catch (std::out_of_range& e) {
81201       {
81202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81203       };
81204     } catch (std::exception& e) {
81205       {
81206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81207       };
81208     } catch (Dali::DaliException e) {
81209       {
81210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81211       };
81212     } catch (...) {
81213       {
81214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81215       };
81216     }
81217   }
81218
81219 }
81220
81221
81222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
81223   void * jresult ;
81224   unsigned int arg1 ;
81225   unsigned int arg2 ;
81226   unsigned int arg3 ;
81227   unsigned int arg4 ;
81228   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81229
81230   arg1 = (unsigned int)jarg1;
81231   arg2 = (unsigned int)jarg2;
81232   arg3 = (unsigned int)jarg3;
81233   arg4 = (unsigned int)jarg4;
81234   {
81235     try {
81236       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
81237     } catch (std::out_of_range& e) {
81238       {
81239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81240       };
81241     } catch (std::exception& e) {
81242       {
81243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81244       };
81245     } catch (Dali::DaliException e) {
81246       {
81247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81248       };
81249     } catch (...) {
81250       {
81251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81252       };
81253     }
81254   }
81255
81256   jresult = (void *)result;
81257   return jresult;
81258 }
81259
81260
81261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
81262   void * jresult ;
81263   unsigned int arg1 ;
81264   unsigned int arg2 ;
81265   unsigned int arg3 ;
81266   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81267
81268   arg1 = (unsigned int)jarg1;
81269   arg2 = (unsigned int)jarg2;
81270   arg3 = (unsigned int)jarg3;
81271   {
81272     try {
81273       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
81274     } catch (std::out_of_range& e) {
81275       {
81276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81277       };
81278     } catch (std::exception& e) {
81279       {
81280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81281       };
81282     } catch (Dali::DaliException e) {
81283       {
81284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81285       };
81286     } catch (...) {
81287       {
81288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81289       };
81290     }
81291   }
81292
81293   jresult = (void *)result;
81294   return jresult;
81295 }
81296
81297
81298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
81299   void * jresult ;
81300   unsigned int arg1 ;
81301   unsigned int arg2 ;
81302   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81303
81304   arg1 = (unsigned int)jarg1;
81305   arg2 = (unsigned int)jarg2;
81306   {
81307     try {
81308       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
81309     } catch (std::out_of_range& e) {
81310       {
81311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81312       };
81313     } catch (std::exception& e) {
81314       {
81315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81316       };
81317     } catch (Dali::DaliException e) {
81318       {
81319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81320       };
81321     } catch (...) {
81322       {
81323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81324       };
81325     }
81326   }
81327
81328   jresult = (void *)result;
81329   return jresult;
81330 }
81331
81332
81333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
81334   void * jresult ;
81335   unsigned int arg1 ;
81336   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81337
81338   arg1 = (unsigned int)jarg1;
81339   {
81340     try {
81341       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
81342     } catch (std::out_of_range& e) {
81343       {
81344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81345       };
81346     } catch (std::exception& e) {
81347       {
81348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81349       };
81350     } catch (Dali::DaliException e) {
81351       {
81352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81353       };
81354     } catch (...) {
81355       {
81356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81357       };
81358     }
81359   }
81360
81361   jresult = (void *)result;
81362   return jresult;
81363 }
81364
81365
81366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
81367   void * jresult ;
81368   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81369
81370   {
81371     try {
81372       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
81373     } catch (std::out_of_range& e) {
81374       {
81375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81376       };
81377     } catch (std::exception& e) {
81378       {
81379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81380       };
81381     } catch (Dali::DaliException e) {
81382       {
81383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81384       };
81385     } catch (...) {
81386       {
81387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81388       };
81389     }
81390   }
81391
81392   jresult = (void *)result;
81393   return jresult;
81394 }
81395
81396
81397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
81398   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81399   unsigned int arg2 ;
81400
81401   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81402   arg2 = (unsigned int)jarg2;
81403   if (arg1) (arg1)->rowIndex = arg2;
81404 }
81405
81406
81407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
81408   unsigned int jresult ;
81409   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81410   unsigned int result;
81411
81412   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81413   result = (unsigned int) ((arg1)->rowIndex);
81414   jresult = result;
81415   return jresult;
81416 }
81417
81418
81419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
81420   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81421   unsigned int arg2 ;
81422
81423   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81424   arg2 = (unsigned int)jarg2;
81425   if (arg1) (arg1)->columnIndex = arg2;
81426 }
81427
81428
81429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
81430   unsigned int jresult ;
81431   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81432   unsigned int result;
81433
81434   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81435   result = (unsigned int) ((arg1)->columnIndex);
81436   jresult = result;
81437   return jresult;
81438 }
81439
81440
81441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
81442   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81443   unsigned int arg2 ;
81444
81445   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81446   arg2 = (unsigned int)jarg2;
81447   if (arg1) (arg1)->rowSpan = arg2;
81448 }
81449
81450
81451 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
81452   unsigned int jresult ;
81453   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81454   unsigned int result;
81455
81456   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81457   result = (unsigned int) ((arg1)->rowSpan);
81458   jresult = result;
81459   return jresult;
81460 }
81461
81462
81463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
81464   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81465   unsigned int arg2 ;
81466
81467   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81468   arg2 = (unsigned int)jarg2;
81469   if (arg1) (arg1)->columnSpan = arg2;
81470 }
81471
81472
81473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
81474   unsigned int jresult ;
81475   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81476   unsigned int result;
81477
81478   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81479   result = (unsigned int) ((arg1)->columnSpan);
81480   jresult = result;
81481   return jresult;
81482 }
81483
81484
81485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
81486   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81487
81488   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81489   {
81490     try {
81491       delete arg1;
81492     } catch (std::out_of_range& e) {
81493       {
81494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81495       };
81496     } catch (std::exception& e) {
81497       {
81498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81499       };
81500     } catch (Dali::DaliException e) {
81501       {
81502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81503       };
81504     } catch (...) {
81505       {
81506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81507       };
81508     }
81509   }
81510
81511 }
81512
81513
81514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
81515   void * jresult ;
81516   Dali::Toolkit::TableView *result = 0 ;
81517
81518   {
81519     try {
81520       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
81521     } catch (std::out_of_range& e) {
81522       {
81523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81524       };
81525     } catch (std::exception& e) {
81526       {
81527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81528       };
81529     } catch (Dali::DaliException e) {
81530       {
81531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81532       };
81533     } catch (...) {
81534       {
81535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81536       };
81537     }
81538   }
81539
81540   jresult = (void *)result;
81541   return jresult;
81542 }
81543
81544
81545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
81546   void * jresult ;
81547   Dali::Toolkit::TableView *arg1 = 0 ;
81548   Dali::Toolkit::TableView *result = 0 ;
81549
81550   arg1 = (Dali::Toolkit::TableView *)jarg1;
81551   if (!arg1) {
81552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
81553     return 0;
81554   }
81555   {
81556     try {
81557       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
81558     } catch (std::out_of_range& e) {
81559       {
81560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81561       };
81562     } catch (std::exception& e) {
81563       {
81564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81565       };
81566     } catch (Dali::DaliException e) {
81567       {
81568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81569       };
81570     } catch (...) {
81571       {
81572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81573       };
81574     }
81575   }
81576
81577   jresult = (void *)result;
81578   return jresult;
81579 }
81580
81581
81582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
81583   void * jresult ;
81584   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81585   Dali::Toolkit::TableView *arg2 = 0 ;
81586   Dali::Toolkit::TableView *result = 0 ;
81587
81588   arg1 = (Dali::Toolkit::TableView *)jarg1;
81589   arg2 = (Dali::Toolkit::TableView *)jarg2;
81590   if (!arg2) {
81591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
81592     return 0;
81593   }
81594   {
81595     try {
81596       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
81597     } catch (std::out_of_range& e) {
81598       {
81599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81600       };
81601     } catch (std::exception& e) {
81602       {
81603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81604       };
81605     } catch (Dali::DaliException e) {
81606       {
81607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81608       };
81609     } catch (...) {
81610       {
81611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81612       };
81613     }
81614   }
81615
81616   jresult = (void *)result;
81617   return jresult;
81618 }
81619
81620
81621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
81622   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81623
81624   arg1 = (Dali::Toolkit::TableView *)jarg1;
81625   {
81626     try {
81627       delete arg1;
81628     } catch (std::out_of_range& e) {
81629       {
81630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81631       };
81632     } catch (std::exception& e) {
81633       {
81634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81635       };
81636     } catch (Dali::DaliException e) {
81637       {
81638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81639       };
81640     } catch (...) {
81641       {
81642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81643       };
81644     }
81645   }
81646
81647 }
81648
81649
81650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
81651   void * jresult ;
81652   unsigned int arg1 ;
81653   unsigned int arg2 ;
81654   Dali::Toolkit::TableView result;
81655
81656   arg1 = (unsigned int)jarg1;
81657   arg2 = (unsigned int)jarg2;
81658   {
81659     try {
81660       result = Dali::Toolkit::TableView::New(arg1,arg2);
81661     } catch (std::out_of_range& e) {
81662       {
81663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81664       };
81665     } catch (std::exception& e) {
81666       {
81667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81668       };
81669     } catch (Dali::DaliException e) {
81670       {
81671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81672       };
81673     } catch (...) {
81674       {
81675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81676       };
81677     }
81678   }
81679
81680   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
81681   return jresult;
81682 }
81683
81684
81685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
81686   void * jresult ;
81687   Dali::BaseHandle arg1 ;
81688   Dali::BaseHandle *argp1 ;
81689   Dali::Toolkit::TableView result;
81690
81691   argp1 = (Dali::BaseHandle *)jarg1;
81692   if (!argp1) {
81693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81694     return 0;
81695   }
81696   arg1 = *argp1;
81697   {
81698     try {
81699       result = Dali::Toolkit::TableView::DownCast(arg1);
81700     } catch (std::out_of_range& e) {
81701       {
81702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81703       };
81704     } catch (std::exception& e) {
81705       {
81706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81707       };
81708     } catch (Dali::DaliException e) {
81709       {
81710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81711       };
81712     } catch (...) {
81713       {
81714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81715       };
81716     }
81717   }
81718
81719   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
81720   return jresult;
81721 }
81722
81723
81724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
81725   unsigned int jresult ;
81726   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81727   Dali::Actor arg2 ;
81728   Dali::Toolkit::TableView::CellPosition arg3 ;
81729   Dali::Actor *argp2 ;
81730   Dali::Toolkit::TableView::CellPosition *argp3 ;
81731   bool result;
81732
81733   arg1 = (Dali::Toolkit::TableView *)jarg1;
81734   argp2 = (Dali::Actor *)jarg2;
81735   if (!argp2) {
81736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81737     return 0;
81738   }
81739   arg2 = *argp2;
81740   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
81741   if (!argp3) {
81742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81743     return 0;
81744   }
81745   arg3 = *argp3;
81746   {
81747     try {
81748       result = (bool)(arg1)->AddChild(arg2,arg3);
81749     } catch (std::out_of_range& e) {
81750       {
81751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81752       };
81753     } catch (std::exception& e) {
81754       {
81755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81756       };
81757     } catch (Dali::DaliException e) {
81758       {
81759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81760       };
81761     } catch (...) {
81762       {
81763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81764       };
81765     }
81766   }
81767
81768   jresult = result;
81769   return jresult;
81770 }
81771
81772
81773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
81774   void * jresult ;
81775   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81776   Dali::Toolkit::TableView::CellPosition arg2 ;
81777   Dali::Toolkit::TableView::CellPosition *argp2 ;
81778   Dali::Actor result;
81779
81780   arg1 = (Dali::Toolkit::TableView *)jarg1;
81781   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
81782   if (!argp2) {
81783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81784     return 0;
81785   }
81786   arg2 = *argp2;
81787   {
81788     try {
81789       result = (arg1)->GetChildAt(arg2);
81790     } catch (std::out_of_range& e) {
81791       {
81792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81793       };
81794     } catch (std::exception& e) {
81795       {
81796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81797       };
81798     } catch (Dali::DaliException e) {
81799       {
81800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81801       };
81802     } catch (...) {
81803       {
81804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81805       };
81806     }
81807   }
81808
81809   jresult = new Dali::Actor((const Dali::Actor &)result);
81810   return jresult;
81811 }
81812
81813
81814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
81815   void * jresult ;
81816   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81817   Dali::Toolkit::TableView::CellPosition arg2 ;
81818   Dali::Toolkit::TableView::CellPosition *argp2 ;
81819   Dali::Actor result;
81820
81821   arg1 = (Dali::Toolkit::TableView *)jarg1;
81822   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
81823   if (!argp2) {
81824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81825     return 0;
81826   }
81827   arg2 = *argp2;
81828   {
81829     try {
81830       result = (arg1)->RemoveChildAt(arg2);
81831     } catch (std::out_of_range& e) {
81832       {
81833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81834       };
81835     } catch (std::exception& e) {
81836       {
81837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81838       };
81839     } catch (Dali::DaliException e) {
81840       {
81841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81842       };
81843     } catch (...) {
81844       {
81845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81846       };
81847     }
81848   }
81849
81850   jresult = new Dali::Actor((const Dali::Actor &)result);
81851   return jresult;
81852 }
81853
81854
81855 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
81856   unsigned int jresult ;
81857   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81858   Dali::Actor arg2 ;
81859   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
81860   Dali::Actor *argp2 ;
81861   bool result;
81862
81863   arg1 = (Dali::Toolkit::TableView *)jarg1;
81864   argp2 = (Dali::Actor *)jarg2;
81865   if (!argp2) {
81866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81867     return 0;
81868   }
81869   arg2 = *argp2;
81870   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
81871   if (!arg3) {
81872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
81873     return 0;
81874   }
81875   {
81876     try {
81877       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
81878     } catch (std::out_of_range& e) {
81879       {
81880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81881       };
81882     } catch (std::exception& e) {
81883       {
81884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81885       };
81886     } catch (Dali::DaliException e) {
81887       {
81888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81889       };
81890     } catch (...) {
81891       {
81892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81893       };
81894     }
81895   }
81896
81897   jresult = result;
81898   return jresult;
81899 }
81900
81901
81902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
81903   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81904   unsigned int arg2 ;
81905
81906   arg1 = (Dali::Toolkit::TableView *)jarg1;
81907   arg2 = (unsigned int)jarg2;
81908   {
81909     try {
81910       (arg1)->InsertRow(arg2);
81911     } catch (std::out_of_range& e) {
81912       {
81913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81914       };
81915     } catch (std::exception& e) {
81916       {
81917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81918       };
81919     } catch (Dali::DaliException e) {
81920       {
81921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81922       };
81923     } catch (...) {
81924       {
81925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81926       };
81927     }
81928   }
81929
81930 }
81931
81932
81933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
81934   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81935   unsigned int arg2 ;
81936
81937   arg1 = (Dali::Toolkit::TableView *)jarg1;
81938   arg2 = (unsigned int)jarg2;
81939   {
81940     try {
81941       (arg1)->DeleteRow(arg2);
81942     } catch (std::out_of_range& e) {
81943       {
81944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81945       };
81946     } catch (std::exception& e) {
81947       {
81948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81949       };
81950     } catch (Dali::DaliException e) {
81951       {
81952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81953       };
81954     } catch (...) {
81955       {
81956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81957       };
81958     }
81959   }
81960
81961 }
81962
81963
81964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
81965   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81966   unsigned int arg2 ;
81967   std::vector< Dali::Actor > *arg3 = 0 ;
81968
81969   arg1 = (Dali::Toolkit::TableView *)jarg1;
81970   arg2 = (unsigned int)jarg2;
81971   arg3 = (std::vector< Dali::Actor > *)jarg3;
81972   if (!arg3) {
81973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
81974     return ;
81975   }
81976   {
81977     try {
81978       (arg1)->DeleteRow(arg2,*arg3);
81979     } catch (std::out_of_range& e) {
81980       {
81981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81982       };
81983     } catch (std::exception& e) {
81984       {
81985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81986       };
81987     } catch (Dali::DaliException e) {
81988       {
81989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81990       };
81991     } catch (...) {
81992       {
81993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81994       };
81995     }
81996   }
81997
81998 }
81999
82000
82001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
82002   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82003   unsigned int arg2 ;
82004
82005   arg1 = (Dali::Toolkit::TableView *)jarg1;
82006   arg2 = (unsigned int)jarg2;
82007   {
82008     try {
82009       (arg1)->InsertColumn(arg2);
82010     } catch (std::out_of_range& e) {
82011       {
82012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82013       };
82014     } catch (std::exception& e) {
82015       {
82016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82017       };
82018     } catch (Dali::DaliException e) {
82019       {
82020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82021       };
82022     } catch (...) {
82023       {
82024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82025       };
82026     }
82027   }
82028
82029 }
82030
82031
82032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
82033   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82034   unsigned int arg2 ;
82035
82036   arg1 = (Dali::Toolkit::TableView *)jarg1;
82037   arg2 = (unsigned int)jarg2;
82038   {
82039     try {
82040       (arg1)->DeleteColumn(arg2);
82041     } catch (std::out_of_range& e) {
82042       {
82043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82044       };
82045     } catch (std::exception& e) {
82046       {
82047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82048       };
82049     } catch (Dali::DaliException e) {
82050       {
82051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82052       };
82053     } catch (...) {
82054       {
82055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82056       };
82057     }
82058   }
82059
82060 }
82061
82062
82063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
82064   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82065   unsigned int arg2 ;
82066   std::vector< Dali::Actor > *arg3 = 0 ;
82067
82068   arg1 = (Dali::Toolkit::TableView *)jarg1;
82069   arg2 = (unsigned int)jarg2;
82070   arg3 = (std::vector< Dali::Actor > *)jarg3;
82071   if (!arg3) {
82072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82073     return ;
82074   }
82075   {
82076     try {
82077       (arg1)->DeleteColumn(arg2,*arg3);
82078     } catch (std::out_of_range& e) {
82079       {
82080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82081       };
82082     } catch (std::exception& e) {
82083       {
82084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82085       };
82086     } catch (Dali::DaliException e) {
82087       {
82088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82089       };
82090     } catch (...) {
82091       {
82092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82093       };
82094     }
82095   }
82096
82097 }
82098
82099
82100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
82101   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82102   unsigned int arg2 ;
82103   unsigned int arg3 ;
82104
82105   arg1 = (Dali::Toolkit::TableView *)jarg1;
82106   arg2 = (unsigned int)jarg2;
82107   arg3 = (unsigned int)jarg3;
82108   {
82109     try {
82110       (arg1)->Resize(arg2,arg3);
82111     } catch (std::out_of_range& e) {
82112       {
82113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82114       };
82115     } catch (std::exception& e) {
82116       {
82117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82118       };
82119     } catch (Dali::DaliException e) {
82120       {
82121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82122       };
82123     } catch (...) {
82124       {
82125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82126       };
82127     }
82128   }
82129
82130 }
82131
82132
82133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
82134   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82135   unsigned int arg2 ;
82136   unsigned int arg3 ;
82137   std::vector< Dali::Actor > *arg4 = 0 ;
82138
82139   arg1 = (Dali::Toolkit::TableView *)jarg1;
82140   arg2 = (unsigned int)jarg2;
82141   arg3 = (unsigned int)jarg3;
82142   arg4 = (std::vector< Dali::Actor > *)jarg4;
82143   if (!arg4) {
82144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82145     return ;
82146   }
82147   {
82148     try {
82149       (arg1)->Resize(arg2,arg3,*arg4);
82150     } catch (std::out_of_range& e) {
82151       {
82152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82153       };
82154     } catch (std::exception& e) {
82155       {
82156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82157       };
82158     } catch (Dali::DaliException e) {
82159       {
82160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82161       };
82162     } catch (...) {
82163       {
82164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82165       };
82166     }
82167   }
82168
82169 }
82170
82171
82172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
82173   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82174   Dali::Size arg2 ;
82175   Dali::Size *argp2 ;
82176
82177   arg1 = (Dali::Toolkit::TableView *)jarg1;
82178   argp2 = (Dali::Size *)jarg2;
82179   if (!argp2) {
82180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
82181     return ;
82182   }
82183   arg2 = *argp2;
82184   {
82185     try {
82186       (arg1)->SetCellPadding(arg2);
82187     } catch (std::out_of_range& e) {
82188       {
82189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82190       };
82191     } catch (std::exception& e) {
82192       {
82193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82194       };
82195     } catch (Dali::DaliException e) {
82196       {
82197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82198       };
82199     } catch (...) {
82200       {
82201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82202       };
82203     }
82204   }
82205
82206 }
82207
82208
82209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
82210   void * jresult ;
82211   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82212   Dali::Size result;
82213
82214   arg1 = (Dali::Toolkit::TableView *)jarg1;
82215   {
82216     try {
82217       result = (arg1)->GetCellPadding();
82218     } catch (std::out_of_range& e) {
82219       {
82220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82221       };
82222     } catch (std::exception& e) {
82223       {
82224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82225       };
82226     } catch (Dali::DaliException e) {
82227       {
82228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82229       };
82230     } catch (...) {
82231       {
82232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82233       };
82234     }
82235   }
82236
82237   jresult = new Dali::Size((const Dali::Size &)result);
82238   return jresult;
82239 }
82240
82241
82242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
82243   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82244   unsigned int arg2 ;
82245
82246   arg1 = (Dali::Toolkit::TableView *)jarg1;
82247   arg2 = (unsigned int)jarg2;
82248   {
82249     try {
82250       (arg1)->SetFitHeight(arg2);
82251     } catch (std::out_of_range& e) {
82252       {
82253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82254       };
82255     } catch (std::exception& e) {
82256       {
82257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82258       };
82259     } catch (Dali::DaliException e) {
82260       {
82261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82262       };
82263     } catch (...) {
82264       {
82265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82266       };
82267     }
82268   }
82269
82270 }
82271
82272
82273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
82274   unsigned int jresult ;
82275   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82276   unsigned int arg2 ;
82277   bool result;
82278
82279   arg1 = (Dali::Toolkit::TableView *)jarg1;
82280   arg2 = (unsigned int)jarg2;
82281   {
82282     try {
82283       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
82284     } catch (std::out_of_range& e) {
82285       {
82286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82287       };
82288     } catch (std::exception& e) {
82289       {
82290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82291       };
82292     } catch (Dali::DaliException e) {
82293       {
82294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82295       };
82296     } catch (...) {
82297       {
82298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82299       };
82300     }
82301   }
82302
82303   jresult = result;
82304   return jresult;
82305 }
82306
82307
82308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
82309   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82310   unsigned int arg2 ;
82311
82312   arg1 = (Dali::Toolkit::TableView *)jarg1;
82313   arg2 = (unsigned int)jarg2;
82314   {
82315     try {
82316       (arg1)->SetFitWidth(arg2);
82317     } catch (std::out_of_range& e) {
82318       {
82319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82320       };
82321     } catch (std::exception& e) {
82322       {
82323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82324       };
82325     } catch (Dali::DaliException e) {
82326       {
82327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82328       };
82329     } catch (...) {
82330       {
82331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82332       };
82333     }
82334   }
82335
82336 }
82337
82338
82339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
82340   unsigned int jresult ;
82341   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82342   unsigned int arg2 ;
82343   bool result;
82344
82345   arg1 = (Dali::Toolkit::TableView *)jarg1;
82346   arg2 = (unsigned int)jarg2;
82347   {
82348     try {
82349       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
82350     } catch (std::out_of_range& e) {
82351       {
82352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82353       };
82354     } catch (std::exception& e) {
82355       {
82356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82357       };
82358     } catch (Dali::DaliException e) {
82359       {
82360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82361       };
82362     } catch (...) {
82363       {
82364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82365       };
82366     }
82367   }
82368
82369   jresult = result;
82370   return jresult;
82371 }
82372
82373
82374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
82375   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82376   unsigned int arg2 ;
82377   float arg3 ;
82378
82379   arg1 = (Dali::Toolkit::TableView *)jarg1;
82380   arg2 = (unsigned int)jarg2;
82381   arg3 = (float)jarg3;
82382   {
82383     try {
82384       (arg1)->SetFixedHeight(arg2,arg3);
82385     } catch (std::out_of_range& e) {
82386       {
82387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82388       };
82389     } catch (std::exception& e) {
82390       {
82391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82392       };
82393     } catch (Dali::DaliException e) {
82394       {
82395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82396       };
82397     } catch (...) {
82398       {
82399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82400       };
82401     }
82402   }
82403
82404 }
82405
82406
82407 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
82408   float jresult ;
82409   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82410   unsigned int arg2 ;
82411   float result;
82412
82413   arg1 = (Dali::Toolkit::TableView *)jarg1;
82414   arg2 = (unsigned int)jarg2;
82415   {
82416     try {
82417       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
82418     } catch (std::out_of_range& e) {
82419       {
82420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82421       };
82422     } catch (std::exception& e) {
82423       {
82424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82425       };
82426     } catch (Dali::DaliException e) {
82427       {
82428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82429       };
82430     } catch (...) {
82431       {
82432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82433       };
82434     }
82435   }
82436
82437   jresult = result;
82438   return jresult;
82439 }
82440
82441
82442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
82443   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82444   unsigned int arg2 ;
82445   float arg3 ;
82446
82447   arg1 = (Dali::Toolkit::TableView *)jarg1;
82448   arg2 = (unsigned int)jarg2;
82449   arg3 = (float)jarg3;
82450   {
82451     try {
82452       (arg1)->SetRelativeHeight(arg2,arg3);
82453     } catch (std::out_of_range& e) {
82454       {
82455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82456       };
82457     } catch (std::exception& e) {
82458       {
82459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82460       };
82461     } catch (Dali::DaliException e) {
82462       {
82463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82464       };
82465     } catch (...) {
82466       {
82467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82468       };
82469     }
82470   }
82471
82472 }
82473
82474
82475 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
82476   float jresult ;
82477   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82478   unsigned int arg2 ;
82479   float result;
82480
82481   arg1 = (Dali::Toolkit::TableView *)jarg1;
82482   arg2 = (unsigned int)jarg2;
82483   {
82484     try {
82485       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
82486     } catch (std::out_of_range& e) {
82487       {
82488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82489       };
82490     } catch (std::exception& e) {
82491       {
82492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82493       };
82494     } catch (Dali::DaliException e) {
82495       {
82496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82497       };
82498     } catch (...) {
82499       {
82500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82501       };
82502     }
82503   }
82504
82505   jresult = result;
82506   return jresult;
82507 }
82508
82509
82510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
82511   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82512   unsigned int arg2 ;
82513   float arg3 ;
82514
82515   arg1 = (Dali::Toolkit::TableView *)jarg1;
82516   arg2 = (unsigned int)jarg2;
82517   arg3 = (float)jarg3;
82518   {
82519     try {
82520       (arg1)->SetFixedWidth(arg2,arg3);
82521     } catch (std::out_of_range& e) {
82522       {
82523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82524       };
82525     } catch (std::exception& e) {
82526       {
82527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82528       };
82529     } catch (Dali::DaliException e) {
82530       {
82531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82532       };
82533     } catch (...) {
82534       {
82535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82536       };
82537     }
82538   }
82539
82540 }
82541
82542
82543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
82544   float jresult ;
82545   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82546   unsigned int arg2 ;
82547   float result;
82548
82549   arg1 = (Dali::Toolkit::TableView *)jarg1;
82550   arg2 = (unsigned int)jarg2;
82551   {
82552     try {
82553       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
82554     } catch (std::out_of_range& e) {
82555       {
82556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82557       };
82558     } catch (std::exception& e) {
82559       {
82560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82561       };
82562     } catch (Dali::DaliException e) {
82563       {
82564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82565       };
82566     } catch (...) {
82567       {
82568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82569       };
82570     }
82571   }
82572
82573   jresult = result;
82574   return jresult;
82575 }
82576
82577
82578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
82579   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82580   unsigned int arg2 ;
82581   float arg3 ;
82582
82583   arg1 = (Dali::Toolkit::TableView *)jarg1;
82584   arg2 = (unsigned int)jarg2;
82585   arg3 = (float)jarg3;
82586   {
82587     try {
82588       (arg1)->SetRelativeWidth(arg2,arg3);
82589     } catch (std::out_of_range& e) {
82590       {
82591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82592       };
82593     } catch (std::exception& e) {
82594       {
82595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82596       };
82597     } catch (Dali::DaliException e) {
82598       {
82599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82600       };
82601     } catch (...) {
82602       {
82603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82604       };
82605     }
82606   }
82607
82608 }
82609
82610
82611 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
82612   float jresult ;
82613   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82614   unsigned int arg2 ;
82615   float result;
82616
82617   arg1 = (Dali::Toolkit::TableView *)jarg1;
82618   arg2 = (unsigned int)jarg2;
82619   {
82620     try {
82621       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
82622     } catch (std::out_of_range& e) {
82623       {
82624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82625       };
82626     } catch (std::exception& e) {
82627       {
82628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82629       };
82630     } catch (Dali::DaliException e) {
82631       {
82632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82633       };
82634     } catch (...) {
82635       {
82636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82637       };
82638     }
82639   }
82640
82641   jresult = result;
82642   return jresult;
82643 }
82644
82645
82646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
82647   unsigned int jresult ;
82648   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82649   unsigned int result;
82650
82651   arg1 = (Dali::Toolkit::TableView *)jarg1;
82652   {
82653     try {
82654       result = (unsigned int)(arg1)->GetRows();
82655     } catch (std::out_of_range& e) {
82656       {
82657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82658       };
82659     } catch (std::exception& e) {
82660       {
82661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82662       };
82663     } catch (Dali::DaliException e) {
82664       {
82665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82666       };
82667     } catch (...) {
82668       {
82669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82670       };
82671     }
82672   }
82673
82674   jresult = result;
82675   return jresult;
82676 }
82677
82678
82679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
82680   unsigned int jresult ;
82681   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82682   unsigned int result;
82683
82684   arg1 = (Dali::Toolkit::TableView *)jarg1;
82685   {
82686     try {
82687       result = (unsigned int)(arg1)->GetColumns();
82688     } catch (std::out_of_range& e) {
82689       {
82690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82691       };
82692     } catch (std::exception& e) {
82693       {
82694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82695       };
82696     } catch (Dali::DaliException e) {
82697       {
82698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82699       };
82700     } catch (...) {
82701       {
82702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82703       };
82704     }
82705   }
82706
82707   jresult = result;
82708   return jresult;
82709 }
82710
82711
82712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
82713   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82714   Dali::Toolkit::TableView::CellPosition arg2 ;
82715   Dali::HorizontalAlignment::Type arg3 ;
82716   Dali::VerticalAlignment::Type arg4 ;
82717   Dali::Toolkit::TableView::CellPosition *argp2 ;
82718
82719   arg1 = (Dali::Toolkit::TableView *)jarg1;
82720   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82721   if (!argp2) {
82722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82723     return ;
82724   }
82725   arg2 = *argp2;
82726   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
82727   arg4 = (Dali::VerticalAlignment::Type)jarg4;
82728   {
82729     try {
82730       (arg1)->SetCellAlignment(arg2,arg3,arg4);
82731     } catch (std::out_of_range& e) {
82732       {
82733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82734       };
82735     } catch (std::exception& e) {
82736       {
82737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82738       };
82739     } catch (Dali::DaliException e) {
82740       {
82741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82742       };
82743     } catch (...) {
82744       {
82745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82746       };
82747     }
82748   }
82749
82750 }
82751
82752
82753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
82754   unsigned int jresult ;
82755   unsigned int result;
82756
82757   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
82758   jresult = result;
82759   return jresult;
82760 }
82761
82762
82763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
82764   int jresult ;
82765   int result;
82766
82767   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
82768   jresult = (int)result;
82769   return jresult;
82770 }
82771
82772
82773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
82774   int jresult ;
82775   int result;
82776
82777   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
82778   jresult = (int)result;
82779   return jresult;
82780 }
82781
82782
82783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
82784   int jresult ;
82785   int result;
82786
82787   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
82788   jresult = (int)result;
82789   return jresult;
82790 }
82791
82792
82793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
82794   int jresult ;
82795   int result;
82796
82797   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
82798   jresult = (int)result;
82799   return jresult;
82800 }
82801
82802
82803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
82804   int jresult ;
82805   int result;
82806
82807   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
82808   jresult = (int)result;
82809   return jresult;
82810 }
82811
82812
82813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
82814   int jresult ;
82815   int result;
82816
82817   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
82818   jresult = (int)result;
82819   return jresult;
82820 }
82821
82822
82823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
82824   int jresult ;
82825   int result;
82826
82827   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
82828   jresult = (int)result;
82829   return jresult;
82830 }
82831
82832
82833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
82834   int jresult ;
82835   int result;
82836
82837   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
82838   jresult = (int)result;
82839   return jresult;
82840 }
82841
82842
82843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
82844   int jresult ;
82845   int result;
82846
82847   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
82848   jresult = (int)result;
82849   return jresult;
82850 }
82851
82852
82853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
82854   int jresult ;
82855   int result;
82856
82857   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
82858   jresult = (int)result;
82859   return jresult;
82860 }
82861
82862
82863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
82864   int jresult ;
82865   int result;
82866
82867   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
82868   jresult = (int)result;
82869   return jresult;
82870 }
82871
82872
82873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
82874   int jresult ;
82875   int result;
82876
82877   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
82878   jresult = (int)result;
82879   return jresult;
82880 }
82881
82882
82883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
82884   int jresult ;
82885   int result;
82886
82887   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
82888   jresult = (int)result;
82889   return jresult;
82890 }
82891
82892
82893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
82894   int jresult ;
82895   int result;
82896
82897   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
82898   jresult = (int)result;
82899   return jresult;
82900 }
82901
82902
82903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
82904   int jresult ;
82905   int result;
82906
82907   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
82908   jresult = (int)result;
82909   return jresult;
82910 }
82911
82912
82913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
82914   int jresult ;
82915   int result;
82916
82917   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
82918   jresult = (int)result;
82919   return jresult;
82920 }
82921
82922
82923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
82924   int jresult ;
82925   int result;
82926
82927   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
82928   jresult = (int)result;
82929   return jresult;
82930 }
82931
82932
82933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
82934   int jresult ;
82935   int result;
82936
82937   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
82938   jresult = (int)result;
82939   return jresult;
82940 }
82941
82942
82943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
82944   int jresult ;
82945   int result;
82946
82947   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
82948   jresult = (int)result;
82949   return jresult;
82950 }
82951
82952
82953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
82954   void * jresult ;
82955   Dali::Toolkit::TextLabel::Property *result = 0 ;
82956
82957   {
82958     try {
82959       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
82960     } catch (std::out_of_range& e) {
82961       {
82962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82963       };
82964     } catch (std::exception& e) {
82965       {
82966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82967       };
82968     } catch (Dali::DaliException e) {
82969       {
82970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82971       };
82972     } catch (...) {
82973       {
82974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82975       };
82976     }
82977   }
82978
82979   jresult = (void *)result;
82980   return jresult;
82981 }
82982
82983
82984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
82985   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
82986
82987   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
82988   {
82989     try {
82990       delete arg1;
82991     } catch (std::out_of_range& e) {
82992       {
82993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82994       };
82995     } catch (std::exception& e) {
82996       {
82997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82998       };
82999     } catch (Dali::DaliException e) {
83000       {
83001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83002       };
83003     } catch (...) {
83004       {
83005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83006       };
83007     }
83008   }
83009
83010 }
83011
83012
83013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
83014   void * jresult ;
83015   Dali::Toolkit::TextLabel result;
83016
83017   {
83018     try {
83019       result = Dali::Toolkit::TextLabel::New();
83020     } catch (std::out_of_range& e) {
83021       {
83022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83023       };
83024     } catch (std::exception& e) {
83025       {
83026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83027       };
83028     } catch (Dali::DaliException e) {
83029       {
83030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83031       };
83032     } catch (...) {
83033       {
83034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83035       };
83036     }
83037   }
83038
83039   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83040   return jresult;
83041 }
83042
83043
83044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
83045   void * jresult ;
83046   std::string *arg1 = 0 ;
83047   Dali::Toolkit::TextLabel result;
83048
83049   if (!jarg1) {
83050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83051     return 0;
83052   }
83053   std::string arg1_str(jarg1);
83054   arg1 = &arg1_str;
83055   {
83056     try {
83057       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
83058     } catch (std::out_of_range& e) {
83059       {
83060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83061       };
83062     } catch (std::exception& e) {
83063       {
83064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83065       };
83066     } catch (Dali::DaliException e) {
83067       {
83068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83069       };
83070     } catch (...) {
83071       {
83072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83073       };
83074     }
83075   }
83076
83077   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83078
83079   //argout typemap for const std::string&
83080
83081   return jresult;
83082 }
83083
83084
83085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
83086   void * jresult ;
83087   Dali::Toolkit::TextLabel *result = 0 ;
83088
83089   {
83090     try {
83091       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
83092     } catch (std::out_of_range& e) {
83093       {
83094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83095       };
83096     } catch (std::exception& e) {
83097       {
83098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83099       };
83100     } catch (Dali::DaliException e) {
83101       {
83102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83103       };
83104     } catch (...) {
83105       {
83106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83107       };
83108     }
83109   }
83110
83111   jresult = (void *)result;
83112   return jresult;
83113 }
83114
83115
83116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
83117   void * jresult ;
83118   Dali::Toolkit::TextLabel *arg1 = 0 ;
83119   Dali::Toolkit::TextLabel *result = 0 ;
83120
83121   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83122   if (!arg1) {
83123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
83124     return 0;
83125   }
83126   {
83127     try {
83128       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
83129     } catch (std::out_of_range& e) {
83130       {
83131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83132       };
83133     } catch (std::exception& e) {
83134       {
83135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83136       };
83137     } catch (Dali::DaliException e) {
83138       {
83139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83140       };
83141     } catch (...) {
83142       {
83143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83144       };
83145     }
83146   }
83147
83148   jresult = (void *)result;
83149   return jresult;
83150 }
83151
83152
83153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
83154   void * jresult ;
83155   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
83156   Dali::Toolkit::TextLabel *arg2 = 0 ;
83157   Dali::Toolkit::TextLabel *result = 0 ;
83158
83159   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83160   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
83161   if (!arg2) {
83162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
83163     return 0;
83164   }
83165   {
83166     try {
83167       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
83168     } catch (std::out_of_range& e) {
83169       {
83170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83171       };
83172     } catch (std::exception& e) {
83173       {
83174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83175       };
83176     } catch (Dali::DaliException e) {
83177       {
83178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83179       };
83180     } catch (...) {
83181       {
83182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83183       };
83184     }
83185   }
83186
83187   jresult = (void *)result;
83188   return jresult;
83189 }
83190
83191
83192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
83193   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
83194
83195   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83196   {
83197     try {
83198       delete arg1;
83199     } catch (std::out_of_range& e) {
83200       {
83201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83202       };
83203     } catch (std::exception& e) {
83204       {
83205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83206       };
83207     } catch (Dali::DaliException e) {
83208       {
83209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83210       };
83211     } catch (...) {
83212       {
83213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83214       };
83215     }
83216   }
83217
83218 }
83219
83220
83221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
83222   void * jresult ;
83223   Dali::BaseHandle arg1 ;
83224   Dali::BaseHandle *argp1 ;
83225   Dali::Toolkit::TextLabel result;
83226
83227   argp1 = (Dali::BaseHandle *)jarg1;
83228   if (!argp1) {
83229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83230     return 0;
83231   }
83232   arg1 = *argp1;
83233   {
83234     try {
83235       result = Dali::Toolkit::TextLabel::DownCast(arg1);
83236     } catch (std::out_of_range& e) {
83237       {
83238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83239       };
83240     } catch (std::exception& e) {
83241       {
83242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83243       };
83244     } catch (Dali::DaliException e) {
83245       {
83246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83247       };
83248     } catch (...) {
83249       {
83250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83251       };
83252     }
83253   }
83254
83255   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83256   return jresult;
83257 }
83258
83259
83260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
83261   void * jresult ;
83262   Dali::Toolkit::AccessibilityManager *result = 0 ;
83263
83264   {
83265     try {
83266       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
83267     } catch (std::out_of_range& e) {
83268       {
83269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83270       };
83271     } catch (std::exception& e) {
83272       {
83273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83274       };
83275     } catch (Dali::DaliException e) {
83276       {
83277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83278       };
83279     } catch (...) {
83280       {
83281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83282       };
83283     }
83284   }
83285
83286   jresult = (void *)result;
83287   return jresult;
83288 }
83289
83290
83291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
83292   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83293
83294   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83295   {
83296     try {
83297       delete arg1;
83298     } catch (std::out_of_range& e) {
83299       {
83300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83301       };
83302     } catch (std::exception& e) {
83303       {
83304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83305       };
83306     } catch (Dali::DaliException e) {
83307       {
83308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83309       };
83310     } catch (...) {
83311       {
83312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83313       };
83314     }
83315   }
83316
83317 }
83318
83319
83320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
83321   void * jresult ;
83322   Dali::Toolkit::AccessibilityManager result;
83323
83324   {
83325     try {
83326       result = Dali::Toolkit::AccessibilityManager::Get();
83327     } catch (std::out_of_range& e) {
83328       {
83329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83330       };
83331     } catch (std::exception& e) {
83332       {
83333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83334       };
83335     } catch (Dali::DaliException e) {
83336       {
83337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83338       };
83339     } catch (...) {
83340       {
83341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83342       };
83343     }
83344   }
83345
83346   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
83347   return jresult;
83348 }
83349
83350
83351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
83352   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83353   Dali::Actor arg2 ;
83354   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
83355   std::string *arg4 = 0 ;
83356   Dali::Actor *argp2 ;
83357
83358   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83359   argp2 = (Dali::Actor *)jarg2;
83360   if (!argp2) {
83361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83362     return ;
83363   }
83364   arg2 = *argp2;
83365   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
83366   if (!jarg4) {
83367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83368     return ;
83369   }
83370   std::string arg4_str(jarg4);
83371   arg4 = &arg4_str;
83372   {
83373     try {
83374       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
83375     } catch (std::out_of_range& e) {
83376       {
83377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83378       };
83379     } catch (std::exception& e) {
83380       {
83381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83382       };
83383     } catch (Dali::DaliException e) {
83384       {
83385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83386       };
83387     } catch (...) {
83388       {
83389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83390       };
83391     }
83392   }
83393
83394
83395   //argout typemap for const std::string&
83396
83397 }
83398
83399
83400 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
83401   char * jresult ;
83402   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83403   Dali::Actor arg2 ;
83404   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
83405   Dali::Actor *argp2 ;
83406   std::string result;
83407
83408   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83409   argp2 = (Dali::Actor *)jarg2;
83410   if (!argp2) {
83411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83412     return 0;
83413   }
83414   arg2 = *argp2;
83415   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
83416   {
83417     try {
83418       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
83419     } catch (std::out_of_range& e) {
83420       {
83421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83422       };
83423     } catch (std::exception& e) {
83424       {
83425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83426       };
83427     } catch (Dali::DaliException e) {
83428       {
83429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83430       };
83431     } catch (...) {
83432       {
83433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83434       };
83435     }
83436   }
83437
83438   jresult = SWIG_csharp_string_callback((&result)->c_str());
83439   return jresult;
83440 }
83441
83442
83443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
83444   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83445   Dali::Actor arg2 ;
83446   unsigned int arg3 ;
83447   Dali::Actor *argp2 ;
83448
83449   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83450   argp2 = (Dali::Actor *)jarg2;
83451   if (!argp2) {
83452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83453     return ;
83454   }
83455   arg2 = *argp2;
83456   arg3 = (unsigned int)jarg3;
83457   {
83458     try {
83459       (arg1)->SetFocusOrder(arg2,arg3);
83460     } catch (std::out_of_range& e) {
83461       {
83462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83463       };
83464     } catch (std::exception& e) {
83465       {
83466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83467       };
83468     } catch (Dali::DaliException e) {
83469       {
83470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83471       };
83472     } catch (...) {
83473       {
83474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83475       };
83476     }
83477   }
83478
83479 }
83480
83481
83482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
83483   unsigned int jresult ;
83484   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83485   Dali::Actor arg2 ;
83486   Dali::Actor *argp2 ;
83487   unsigned int result;
83488
83489   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83490   argp2 = (Dali::Actor *)jarg2;
83491   if (!argp2) {
83492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83493     return 0;
83494   }
83495   arg2 = *argp2;
83496   {
83497     try {
83498       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
83499     } catch (std::out_of_range& e) {
83500       {
83501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83502       };
83503     } catch (std::exception& e) {
83504       {
83505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83506       };
83507     } catch (Dali::DaliException e) {
83508       {
83509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83510       };
83511     } catch (...) {
83512       {
83513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83514       };
83515     }
83516   }
83517
83518   jresult = result;
83519   return jresult;
83520 }
83521
83522
83523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
83524   unsigned int jresult ;
83525   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83526   unsigned int result;
83527
83528   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83529   {
83530     try {
83531       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
83532     } catch (std::out_of_range& e) {
83533       {
83534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83535       };
83536     } catch (std::exception& e) {
83537       {
83538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83539       };
83540     } catch (Dali::DaliException e) {
83541       {
83542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83543       };
83544     } catch (...) {
83545       {
83546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83547       };
83548     }
83549   }
83550
83551   jresult = result;
83552   return jresult;
83553 }
83554
83555
83556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
83557   void * jresult ;
83558   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83559   unsigned int arg2 ;
83560   Dali::Actor result;
83561
83562   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83563   arg2 = (unsigned int)jarg2;
83564   {
83565     try {
83566       result = (arg1)->GetActorByFocusOrder(arg2);
83567     } catch (std::out_of_range& e) {
83568       {
83569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83570       };
83571     } catch (std::exception& e) {
83572       {
83573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83574       };
83575     } catch (Dali::DaliException e) {
83576       {
83577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83578       };
83579     } catch (...) {
83580       {
83581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83582       };
83583     }
83584   }
83585
83586   jresult = new Dali::Actor((const Dali::Actor &)result);
83587   return jresult;
83588 }
83589
83590
83591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
83592   unsigned int jresult ;
83593   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83594   Dali::Actor arg2 ;
83595   Dali::Actor *argp2 ;
83596   bool result;
83597
83598   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83599   argp2 = (Dali::Actor *)jarg2;
83600   if (!argp2) {
83601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83602     return 0;
83603   }
83604   arg2 = *argp2;
83605   {
83606     try {
83607       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
83608     } catch (std::out_of_range& e) {
83609       {
83610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83611       };
83612     } catch (std::exception& e) {
83613       {
83614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83615       };
83616     } catch (Dali::DaliException e) {
83617       {
83618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83619       };
83620     } catch (...) {
83621       {
83622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83623       };
83624     }
83625   }
83626
83627   jresult = result;
83628   return jresult;
83629 }
83630
83631
83632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
83633   void * jresult ;
83634   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83635   Dali::Actor result;
83636
83637   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83638   {
83639     try {
83640       result = (arg1)->GetCurrentFocusActor();
83641     } catch (std::out_of_range& e) {
83642       {
83643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83644       };
83645     } catch (std::exception& e) {
83646       {
83647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83648       };
83649     } catch (Dali::DaliException e) {
83650       {
83651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83652       };
83653     } catch (...) {
83654       {
83655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83656       };
83657     }
83658   }
83659
83660   jresult = new Dali::Actor((const Dali::Actor &)result);
83661   return jresult;
83662 }
83663
83664
83665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
83666   void * jresult ;
83667   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83668   Dali::Actor result;
83669
83670   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83671   {
83672     try {
83673       result = (arg1)->GetCurrentFocusGroup();
83674     } catch (std::out_of_range& e) {
83675       {
83676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83677       };
83678     } catch (std::exception& e) {
83679       {
83680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83681       };
83682     } catch (Dali::DaliException e) {
83683       {
83684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83685       };
83686     } catch (...) {
83687       {
83688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83689       };
83690     }
83691   }
83692
83693   jresult = new Dali::Actor((const Dali::Actor &)result);
83694   return jresult;
83695 }
83696
83697
83698 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
83699   unsigned int jresult ;
83700   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83701   unsigned int result;
83702
83703   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83704   {
83705     try {
83706       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
83707     } catch (std::out_of_range& e) {
83708       {
83709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83710       };
83711     } catch (std::exception& e) {
83712       {
83713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83714       };
83715     } catch (Dali::DaliException e) {
83716       {
83717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83718       };
83719     } catch (...) {
83720       {
83721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83722       };
83723     }
83724   }
83725
83726   jresult = result;
83727   return jresult;
83728 }
83729
83730
83731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
83732   unsigned int jresult ;
83733   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83734   bool result;
83735
83736   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83737   {
83738     try {
83739       result = (bool)(arg1)->MoveFocusForward();
83740     } catch (std::out_of_range& e) {
83741       {
83742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83743       };
83744     } catch (std::exception& e) {
83745       {
83746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83747       };
83748     } catch (Dali::DaliException e) {
83749       {
83750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83751       };
83752     } catch (...) {
83753       {
83754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83755       };
83756     }
83757   }
83758
83759   jresult = result;
83760   return jresult;
83761 }
83762
83763
83764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
83765   unsigned int jresult ;
83766   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83767   bool result;
83768
83769   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83770   {
83771     try {
83772       result = (bool)(arg1)->MoveFocusBackward();
83773     } catch (std::out_of_range& e) {
83774       {
83775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83776       };
83777     } catch (std::exception& e) {
83778       {
83779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83780       };
83781     } catch (Dali::DaliException e) {
83782       {
83783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83784       };
83785     } catch (...) {
83786       {
83787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83788       };
83789     }
83790   }
83791
83792   jresult = result;
83793   return jresult;
83794 }
83795
83796
83797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
83798   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83799
83800   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83801   {
83802     try {
83803       (arg1)->ClearFocus();
83804     } catch (std::out_of_range& e) {
83805       {
83806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83807       };
83808     } catch (std::exception& e) {
83809       {
83810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83811       };
83812     } catch (Dali::DaliException e) {
83813       {
83814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83815       };
83816     } catch (...) {
83817       {
83818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83819       };
83820     }
83821   }
83822
83823 }
83824
83825
83826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
83827   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83828
83829   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83830   {
83831     try {
83832       (arg1)->Reset();
83833     } catch (std::out_of_range& e) {
83834       {
83835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83836       };
83837     } catch (std::exception& e) {
83838       {
83839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83840       };
83841     } catch (Dali::DaliException e) {
83842       {
83843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83844       };
83845     } catch (...) {
83846       {
83847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83848       };
83849     }
83850   }
83851
83852 }
83853
83854
83855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
83856   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83857   Dali::Actor arg2 ;
83858   bool arg3 ;
83859   Dali::Actor *argp2 ;
83860
83861   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83862   argp2 = (Dali::Actor *)jarg2;
83863   if (!argp2) {
83864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83865     return ;
83866   }
83867   arg2 = *argp2;
83868   arg3 = jarg3 ? true : false;
83869   {
83870     try {
83871       (arg1)->SetFocusGroup(arg2,arg3);
83872     } catch (std::out_of_range& e) {
83873       {
83874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83875       };
83876     } catch (std::exception& e) {
83877       {
83878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83879       };
83880     } catch (Dali::DaliException e) {
83881       {
83882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83883       };
83884     } catch (...) {
83885       {
83886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83887       };
83888     }
83889   }
83890
83891 }
83892
83893
83894 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
83895   unsigned int jresult ;
83896   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83897   Dali::Actor arg2 ;
83898   Dali::Actor *argp2 ;
83899   bool result;
83900
83901   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83902   argp2 = (Dali::Actor *)jarg2;
83903   if (!argp2) {
83904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83905     return 0;
83906   }
83907   arg2 = *argp2;
83908   {
83909     try {
83910       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
83911     } catch (std::out_of_range& e) {
83912       {
83913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83914       };
83915     } catch (std::exception& e) {
83916       {
83917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83918       };
83919     } catch (Dali::DaliException e) {
83920       {
83921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83922       };
83923     } catch (...) {
83924       {
83925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83926       };
83927     }
83928   }
83929
83930   jresult = result;
83931   return jresult;
83932 }
83933
83934
83935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
83936   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83937   bool arg2 ;
83938
83939   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83940   arg2 = jarg2 ? true : false;
83941   {
83942     try {
83943       (arg1)->SetGroupMode(arg2);
83944     } catch (std::out_of_range& e) {
83945       {
83946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83947       };
83948     } catch (std::exception& e) {
83949       {
83950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83951       };
83952     } catch (Dali::DaliException e) {
83953       {
83954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83955       };
83956     } catch (...) {
83957       {
83958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83959       };
83960     }
83961   }
83962
83963 }
83964
83965
83966 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
83967   unsigned int jresult ;
83968   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83969   bool result;
83970
83971   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83972   {
83973     try {
83974       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
83975     } catch (std::out_of_range& e) {
83976       {
83977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83978       };
83979     } catch (std::exception& e) {
83980       {
83981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83982       };
83983     } catch (Dali::DaliException e) {
83984       {
83985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83986       };
83987     } catch (...) {
83988       {
83989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83990       };
83991     }
83992   }
83993
83994   jresult = result;
83995   return jresult;
83996 }
83997
83998
83999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
84000   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84001   bool arg2 ;
84002
84003   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84004   arg2 = jarg2 ? true : false;
84005   {
84006     try {
84007       (arg1)->SetWrapMode(arg2);
84008     } catch (std::out_of_range& e) {
84009       {
84010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84011       };
84012     } catch (std::exception& e) {
84013       {
84014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84015       };
84016     } catch (Dali::DaliException e) {
84017       {
84018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84019       };
84020     } catch (...) {
84021       {
84022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84023       };
84024     }
84025   }
84026
84027 }
84028
84029
84030 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
84031   unsigned int jresult ;
84032   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84033   bool result;
84034
84035   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84036   {
84037     try {
84038       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
84039     } catch (std::out_of_range& e) {
84040       {
84041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84042       };
84043     } catch (std::exception& e) {
84044       {
84045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84046       };
84047     } catch (Dali::DaliException e) {
84048       {
84049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84050       };
84051     } catch (...) {
84052       {
84053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84054       };
84055     }
84056   }
84057
84058   jresult = result;
84059   return jresult;
84060 }
84061
84062
84063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
84064   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84065   Dali::Actor arg2 ;
84066   Dali::Actor *argp2 ;
84067
84068   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84069   argp2 = (Dali::Actor *)jarg2;
84070   if (!argp2) {
84071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84072     return ;
84073   }
84074   arg2 = *argp2;
84075   {
84076     try {
84077       (arg1)->SetFocusIndicatorActor(arg2);
84078     } catch (std::out_of_range& e) {
84079       {
84080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84081       };
84082     } catch (std::exception& e) {
84083       {
84084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84085       };
84086     } catch (Dali::DaliException e) {
84087       {
84088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84089       };
84090     } catch (...) {
84091       {
84092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84093       };
84094     }
84095   }
84096
84097 }
84098
84099
84100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
84101   void * jresult ;
84102   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84103   Dali::Actor result;
84104
84105   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84106   {
84107     try {
84108       result = (arg1)->GetFocusIndicatorActor();
84109     } catch (std::out_of_range& e) {
84110       {
84111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84112       };
84113     } catch (std::exception& e) {
84114       {
84115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84116       };
84117     } catch (Dali::DaliException e) {
84118       {
84119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84120       };
84121     } catch (...) {
84122       {
84123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84124       };
84125     }
84126   }
84127
84128   jresult = new Dali::Actor((const Dali::Actor &)result);
84129   return jresult;
84130 }
84131
84132
84133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
84134   void * jresult ;
84135   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84136   Dali::Actor arg2 ;
84137   Dali::Actor *argp2 ;
84138   Dali::Actor result;
84139
84140   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84141   argp2 = (Dali::Actor *)jarg2;
84142   if (!argp2) {
84143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84144     return 0;
84145   }
84146   arg2 = *argp2;
84147   {
84148     try {
84149       result = (arg1)->GetFocusGroup(arg2);
84150     } catch (std::out_of_range& e) {
84151       {
84152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84153       };
84154     } catch (std::exception& e) {
84155       {
84156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84157       };
84158     } catch (Dali::DaliException e) {
84159       {
84160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84161       };
84162     } catch (...) {
84163       {
84164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84165       };
84166     }
84167   }
84168
84169   jresult = new Dali::Actor((const Dali::Actor &)result);
84170   return jresult;
84171 }
84172
84173
84174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
84175   void * jresult ;
84176   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84177   Dali::Vector2 result;
84178
84179   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84180   {
84181     try {
84182       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
84183     } catch (std::out_of_range& e) {
84184       {
84185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84186       };
84187     } catch (std::exception& e) {
84188       {
84189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84190       };
84191     } catch (Dali::DaliException e) {
84192       {
84193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84194       };
84195     } catch (...) {
84196       {
84197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84198       };
84199     }
84200   }
84201
84202   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
84203   return jresult;
84204 }
84205
84206
84207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
84208   void * jresult ;
84209   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84210   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
84211
84212   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84213   {
84214     try {
84215       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
84216     } catch (std::out_of_range& e) {
84217       {
84218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84219       };
84220     } catch (std::exception& e) {
84221       {
84222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84223       };
84224     } catch (Dali::DaliException e) {
84225       {
84226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84227       };
84228     } catch (...) {
84229       {
84230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84231       };
84232     }
84233   }
84234
84235   jresult = (void *)result;
84236   return jresult;
84237 }
84238
84239
84240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
84241   void * jresult ;
84242   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84243   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
84244
84245   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84246   {
84247     try {
84248       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
84249     } catch (std::out_of_range& e) {
84250       {
84251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84252       };
84253     } catch (std::exception& e) {
84254       {
84255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84256       };
84257     } catch (Dali::DaliException e) {
84258       {
84259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84260       };
84261     } catch (...) {
84262       {
84263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84264       };
84265     }
84266   }
84267
84268   jresult = (void *)result;
84269   return jresult;
84270 }
84271
84272
84273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
84274   void * jresult ;
84275   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84276   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
84277
84278   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84279   {
84280     try {
84281       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
84282     } catch (std::out_of_range& e) {
84283       {
84284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84285       };
84286     } catch (std::exception& e) {
84287       {
84288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84289       };
84290     } catch (Dali::DaliException e) {
84291       {
84292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84293       };
84294     } catch (...) {
84295       {
84296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84297       };
84298     }
84299   }
84300
84301   jresult = (void *)result;
84302   return jresult;
84303 }
84304
84305
84306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
84307   void * jresult ;
84308   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84309   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84310
84311   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84312   {
84313     try {
84314       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
84315     } catch (std::out_of_range& e) {
84316       {
84317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84318       };
84319     } catch (std::exception& e) {
84320       {
84321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84322       };
84323     } catch (Dali::DaliException e) {
84324       {
84325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84326       };
84327     } catch (...) {
84328       {
84329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84330       };
84331     }
84332   }
84333
84334   jresult = (void *)result;
84335   return jresult;
84336 }
84337
84338
84339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
84340   void * jresult ;
84341   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84342   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84343
84344   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84345   {
84346     try {
84347       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
84348     } catch (std::out_of_range& e) {
84349       {
84350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84351       };
84352     } catch (std::exception& e) {
84353       {
84354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84355       };
84356     } catch (Dali::DaliException e) {
84357       {
84358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84359       };
84360     } catch (...) {
84361       {
84362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84363       };
84364     }
84365   }
84366
84367   jresult = (void *)result;
84368   return jresult;
84369 }
84370
84371
84372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
84373   void * jresult ;
84374   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84375   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84376
84377   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84378   {
84379     try {
84380       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
84381     } catch (std::out_of_range& e) {
84382       {
84383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84384       };
84385     } catch (std::exception& e) {
84386       {
84387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84388       };
84389     } catch (Dali::DaliException e) {
84390       {
84391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84392       };
84393     } catch (...) {
84394       {
84395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84396       };
84397     }
84398   }
84399
84400   jresult = (void *)result;
84401   return jresult;
84402 }
84403
84404
84405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
84406   void * jresult ;
84407   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84408   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84409
84410   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84411   {
84412     try {
84413       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
84414     } catch (std::out_of_range& e) {
84415       {
84416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84417       };
84418     } catch (std::exception& e) {
84419       {
84420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84421       };
84422     } catch (Dali::DaliException e) {
84423       {
84424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84425       };
84426     } catch (...) {
84427       {
84428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84429       };
84430     }
84431   }
84432
84433   jresult = (void *)result;
84434   return jresult;
84435 }
84436
84437
84438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
84439   void * jresult ;
84440   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84441   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84442
84443   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84444   {
84445     try {
84446       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
84447     } catch (std::out_of_range& e) {
84448       {
84449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84450       };
84451     } catch (std::exception& e) {
84452       {
84453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84454       };
84455     } catch (Dali::DaliException e) {
84456       {
84457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84458       };
84459     } catch (...) {
84460       {
84461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84462       };
84463     }
84464   }
84465
84466   jresult = (void *)result;
84467   return jresult;
84468 }
84469
84470
84471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
84472   void * jresult ;
84473   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84474   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84475
84476   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84477   {
84478     try {
84479       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
84480     } catch (std::out_of_range& e) {
84481       {
84482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84483       };
84484     } catch (std::exception& e) {
84485       {
84486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84487       };
84488     } catch (Dali::DaliException e) {
84489       {
84490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84491       };
84492     } catch (...) {
84493       {
84494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84495       };
84496     }
84497   }
84498
84499   jresult = (void *)result;
84500   return jresult;
84501 }
84502
84503
84504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
84505   void * jresult ;
84506   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84507   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84508
84509   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84510   {
84511     try {
84512       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
84513     } catch (std::out_of_range& e) {
84514       {
84515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84516       };
84517     } catch (std::exception& e) {
84518       {
84519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84520       };
84521     } catch (Dali::DaliException e) {
84522       {
84523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84524       };
84525     } catch (...) {
84526       {
84527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84528       };
84529     }
84530   }
84531
84532   jresult = (void *)result;
84533   return jresult;
84534 }
84535
84536
84537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
84538   void * jresult ;
84539   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84540   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84541
84542   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84543   {
84544     try {
84545       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
84546     } catch (std::out_of_range& e) {
84547       {
84548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84549       };
84550     } catch (std::exception& e) {
84551       {
84552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84553       };
84554     } catch (Dali::DaliException e) {
84555       {
84556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84557       };
84558     } catch (...) {
84559       {
84560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84561       };
84562     }
84563   }
84564
84565   jresult = (void *)result;
84566   return jresult;
84567 }
84568
84569
84570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
84571   void * jresult ;
84572   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84573   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84574
84575   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84576   {
84577     try {
84578       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
84579     } catch (std::out_of_range& e) {
84580       {
84581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84582       };
84583     } catch (std::exception& e) {
84584       {
84585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84586       };
84587     } catch (Dali::DaliException e) {
84588       {
84589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84590       };
84591     } catch (...) {
84592       {
84593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84594       };
84595     }
84596   }
84597
84598   jresult = (void *)result;
84599   return jresult;
84600 }
84601
84602
84603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
84604   void * jresult ;
84605   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84606   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84607
84608   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84609   {
84610     try {
84611       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
84612     } catch (std::out_of_range& e) {
84613       {
84614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84615       };
84616     } catch (std::exception& e) {
84617       {
84618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84619       };
84620     } catch (Dali::DaliException e) {
84621       {
84622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84623       };
84624     } catch (...) {
84625       {
84626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84627       };
84628     }
84629   }
84630
84631   jresult = (void *)result;
84632   return jresult;
84633 }
84634
84635
84636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
84637   void * jresult ;
84638   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84639   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84640
84641   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84642   {
84643     try {
84644       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
84645     } catch (std::out_of_range& e) {
84646       {
84647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84648       };
84649     } catch (std::exception& e) {
84650       {
84651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84652       };
84653     } catch (Dali::DaliException e) {
84654       {
84655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84656       };
84657     } catch (...) {
84658       {
84659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84660       };
84661     }
84662   }
84663
84664   jresult = (void *)result;
84665   return jresult;
84666 }
84667
84668
84669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
84670   void * jresult ;
84671   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84672   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84673
84674   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84675   {
84676     try {
84677       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
84678     } catch (std::out_of_range& e) {
84679       {
84680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84681       };
84682     } catch (std::exception& e) {
84683       {
84684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84685       };
84686     } catch (Dali::DaliException e) {
84687       {
84688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84689       };
84690     } catch (...) {
84691       {
84692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84693       };
84694     }
84695   }
84696
84697   jresult = (void *)result;
84698   return jresult;
84699 }
84700
84701
84702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
84703   void * jresult ;
84704   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84705   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84706
84707   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84708   {
84709     try {
84710       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
84711     } catch (std::out_of_range& e) {
84712       {
84713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84714       };
84715     } catch (std::exception& e) {
84716       {
84717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84718       };
84719     } catch (Dali::DaliException e) {
84720       {
84721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84722       };
84723     } catch (...) {
84724       {
84725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84726       };
84727     }
84728   }
84729
84730   jresult = (void *)result;
84731   return jresult;
84732 }
84733
84734
84735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
84736   void * jresult ;
84737   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84738   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84739
84740   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84741   {
84742     try {
84743       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
84744     } catch (std::out_of_range& e) {
84745       {
84746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84747       };
84748     } catch (std::exception& e) {
84749       {
84750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84751       };
84752     } catch (Dali::DaliException e) {
84753       {
84754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84755       };
84756     } catch (...) {
84757       {
84758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84759       };
84760     }
84761   }
84762
84763   jresult = (void *)result;
84764   return jresult;
84765 }
84766
84767
84768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
84769   void * jresult ;
84770   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84771   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84772
84773   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84774   {
84775     try {
84776       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
84777     } catch (std::out_of_range& e) {
84778       {
84779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84780       };
84781     } catch (std::exception& e) {
84782       {
84783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84784       };
84785     } catch (Dali::DaliException e) {
84786       {
84787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84788       };
84789     } catch (...) {
84790       {
84791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84792       };
84793     }
84794   }
84795
84796   jresult = (void *)result;
84797   return jresult;
84798 }
84799
84800
84801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
84802   void * jresult ;
84803   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84804   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84805
84806   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84807   {
84808     try {
84809       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
84810     } catch (std::out_of_range& e) {
84811       {
84812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84813       };
84814     } catch (std::exception& e) {
84815       {
84816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84817       };
84818     } catch (Dali::DaliException e) {
84819       {
84820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84821       };
84822     } catch (...) {
84823       {
84824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84825       };
84826     }
84827   }
84828
84829   jresult = (void *)result;
84830   return jresult;
84831 }
84832
84833
84834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
84835   void * jresult ;
84836   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84837   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84838
84839   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84840   {
84841     try {
84842       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
84843     } catch (std::out_of_range& e) {
84844       {
84845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84846       };
84847     } catch (std::exception& e) {
84848       {
84849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84850       };
84851     } catch (Dali::DaliException e) {
84852       {
84853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84854       };
84855     } catch (...) {
84856       {
84857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84858       };
84859     }
84860   }
84861
84862   jresult = (void *)result;
84863   return jresult;
84864 }
84865
84866
84867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
84868   void * jresult ;
84869   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84870   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84871
84872   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84873   {
84874     try {
84875       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
84876     } catch (std::out_of_range& e) {
84877       {
84878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84879       };
84880     } catch (std::exception& e) {
84881       {
84882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84883       };
84884     } catch (Dali::DaliException e) {
84885       {
84886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84887       };
84888     } catch (...) {
84889       {
84890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84891       };
84892     }
84893   }
84894
84895   jresult = (void *)result;
84896   return jresult;
84897 }
84898
84899
84900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
84901   void * jresult ;
84902   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84903   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84904
84905   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84906   {
84907     try {
84908       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
84909     } catch (std::out_of_range& e) {
84910       {
84911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84912       };
84913     } catch (std::exception& e) {
84914       {
84915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84916       };
84917     } catch (Dali::DaliException e) {
84918       {
84919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84920       };
84921     } catch (...) {
84922       {
84923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84924       };
84925     }
84926   }
84927
84928   jresult = (void *)result;
84929   return jresult;
84930 }
84931
84932
84933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
84934   void * jresult ;
84935   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84936   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84937
84938   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84939   {
84940     try {
84941       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
84942     } catch (std::out_of_range& e) {
84943       {
84944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84945       };
84946     } catch (std::exception& e) {
84947       {
84948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84949       };
84950     } catch (Dali::DaliException e) {
84951       {
84952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84953       };
84954     } catch (...) {
84955       {
84956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84957       };
84958     }
84959   }
84960
84961   jresult = (void *)result;
84962   return jresult;
84963 }
84964
84965
84966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
84967   void * jresult ;
84968   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84969   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84970
84971   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84972   {
84973     try {
84974       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
84975     } catch (std::out_of_range& e) {
84976       {
84977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84978       };
84979     } catch (std::exception& e) {
84980       {
84981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84982       };
84983     } catch (Dali::DaliException e) {
84984       {
84985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84986       };
84987     } catch (...) {
84988       {
84989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84990       };
84991     }
84992   }
84993
84994   jresult = (void *)result;
84995   return jresult;
84996 }
84997
84998
84999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
85000   void * jresult ;
85001   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85002   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85003
85004   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85005   {
85006     try {
85007       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
85008     } catch (std::out_of_range& e) {
85009       {
85010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85011       };
85012     } catch (std::exception& e) {
85013       {
85014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85015       };
85016     } catch (Dali::DaliException e) {
85017       {
85018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85019       };
85020     } catch (...) {
85021       {
85022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85023       };
85024     }
85025   }
85026
85027   jresult = (void *)result;
85028   return jresult;
85029 }
85030
85031
85032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
85033   void * jresult ;
85034   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85035   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85036
85037   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85038   {
85039     try {
85040       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
85041     } catch (std::out_of_range& e) {
85042       {
85043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85044       };
85045     } catch (std::exception& e) {
85046       {
85047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85048       };
85049     } catch (Dali::DaliException e) {
85050       {
85051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85052       };
85053     } catch (...) {
85054       {
85055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85056       };
85057     }
85058   }
85059
85060   jresult = (void *)result;
85061   return jresult;
85062 }
85063
85064
85065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
85066   void * jresult ;
85067   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85068   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85069
85070   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85071   {
85072     try {
85073       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
85074     } catch (std::out_of_range& e) {
85075       {
85076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85077       };
85078     } catch (std::exception& e) {
85079       {
85080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85081       };
85082     } catch (Dali::DaliException e) {
85083       {
85084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85085       };
85086     } catch (...) {
85087       {
85088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85089       };
85090     }
85091   }
85092
85093   jresult = (void *)result;
85094   return jresult;
85095 }
85096
85097
85098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
85099   void * jresult ;
85100   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85101   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85102
85103   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85104   {
85105     try {
85106       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
85107     } catch (std::out_of_range& e) {
85108       {
85109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85110       };
85111     } catch (std::exception& e) {
85112       {
85113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85114       };
85115     } catch (Dali::DaliException e) {
85116       {
85117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85118       };
85119     } catch (...) {
85120       {
85121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85122       };
85123     }
85124   }
85125
85126   jresult = (void *)result;
85127   return jresult;
85128 }
85129
85130
85131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
85132   void * jresult ;
85133   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85134   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85135
85136   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85137   {
85138     try {
85139       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
85140     } catch (std::out_of_range& e) {
85141       {
85142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85143       };
85144     } catch (std::exception& e) {
85145       {
85146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85147       };
85148     } catch (Dali::DaliException e) {
85149       {
85150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85151       };
85152     } catch (...) {
85153       {
85154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85155       };
85156     }
85157   }
85158
85159   jresult = (void *)result;
85160   return jresult;
85161 }
85162
85163
85164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
85165   void * jresult ;
85166   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85167   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
85168
85169   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85170   {
85171     try {
85172       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
85173     } catch (std::out_of_range& e) {
85174       {
85175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85176       };
85177     } catch (std::exception& e) {
85178       {
85179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85180       };
85181     } catch (Dali::DaliException e) {
85182       {
85183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85184       };
85185     } catch (...) {
85186       {
85187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85188       };
85189     }
85190   }
85191
85192   jresult = (void *)result;
85193   return jresult;
85194 }
85195
85196
85197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
85198   void * jresult ;
85199   Dali::Toolkit::StyleManager *result = 0 ;
85200
85201   {
85202     try {
85203       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
85204     } catch (std::out_of_range& e) {
85205       {
85206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85207       };
85208     } catch (std::exception& e) {
85209       {
85210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85211       };
85212     } catch (Dali::DaliException e) {
85213       {
85214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85215       };
85216     } catch (...) {
85217       {
85218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85219       };
85220     }
85221   }
85222
85223   jresult = (void *)result;
85224   return jresult;
85225 }
85226
85227
85228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
85229   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85230
85231   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85232   {
85233     try {
85234       delete arg1;
85235     } catch (std::out_of_range& e) {
85236       {
85237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85238       };
85239     } catch (std::exception& e) {
85240       {
85241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85242       };
85243     } catch (Dali::DaliException e) {
85244       {
85245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85246       };
85247     } catch (...) {
85248       {
85249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85250       };
85251     }
85252   }
85253
85254 }
85255
85256
85257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
85258   void * jresult ;
85259   Dali::Toolkit::StyleManager result;
85260
85261   {
85262     try {
85263       result = Dali::Toolkit::StyleManager::Get();
85264     } catch (std::out_of_range& e) {
85265       {
85266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85267       };
85268     } catch (std::exception& e) {
85269       {
85270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85271       };
85272     } catch (Dali::DaliException e) {
85273       {
85274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85275       };
85276     } catch (...) {
85277       {
85278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85279       };
85280     }
85281   }
85282
85283   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
85284   return jresult;
85285 }
85286
85287
85288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
85289   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85290   std::string *arg2 = 0 ;
85291
85292   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85293   if (!jarg2) {
85294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85295     return ;
85296   }
85297   std::string arg2_str(jarg2);
85298   arg2 = &arg2_str;
85299   {
85300     try {
85301       (arg1)->ApplyTheme((std::string const &)*arg2);
85302     } catch (std::out_of_range& e) {
85303       {
85304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85305       };
85306     } catch (std::exception& e) {
85307       {
85308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85309       };
85310     } catch (Dali::DaliException e) {
85311       {
85312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85313       };
85314     } catch (...) {
85315       {
85316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85317       };
85318     }
85319   }
85320
85321
85322   //argout typemap for const std::string&
85323
85324 }
85325
85326
85327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
85328   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85329
85330   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85331   {
85332     try {
85333       (arg1)->ApplyDefaultTheme();
85334     } catch (std::out_of_range& e) {
85335       {
85336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85337       };
85338     } catch (std::exception& e) {
85339       {
85340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85341       };
85342     } catch (Dali::DaliException e) {
85343       {
85344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85345       };
85346     } catch (...) {
85347       {
85348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85349       };
85350     }
85351   }
85352
85353 }
85354
85355
85356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
85357   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85358   std::string *arg2 = 0 ;
85359   Dali::Property::Value *arg3 = 0 ;
85360
85361   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85362   if (!jarg2) {
85363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85364     return ;
85365   }
85366   std::string arg2_str(jarg2);
85367   arg2 = &arg2_str;
85368   arg3 = (Dali::Property::Value *)jarg3;
85369   if (!arg3) {
85370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
85371     return ;
85372   }
85373   {
85374     try {
85375       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
85376     } catch (std::out_of_range& e) {
85377       {
85378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85379       };
85380     } catch (std::exception& e) {
85381       {
85382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85383       };
85384     } catch (Dali::DaliException e) {
85385       {
85386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85387       };
85388     } catch (...) {
85389       {
85390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85391       };
85392     }
85393   }
85394
85395
85396   //argout typemap for const std::string&
85397
85398 }
85399
85400
85401 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
85402   unsigned int jresult ;
85403   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85404   std::string *arg2 = 0 ;
85405   Dali::Property::Value *arg3 = 0 ;
85406   bool result;
85407
85408   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85409   if (!jarg2) {
85410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85411     return 0;
85412   }
85413   std::string arg2_str(jarg2);
85414   arg2 = &arg2_str;
85415   arg3 = (Dali::Property::Value *)jarg3;
85416   if (!arg3) {
85417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
85418     return 0;
85419   }
85420   {
85421     try {
85422       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
85423     } catch (std::out_of_range& e) {
85424       {
85425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85426       };
85427     } catch (std::exception& e) {
85428       {
85429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85430       };
85431     } catch (Dali::DaliException e) {
85432       {
85433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85434       };
85435     } catch (...) {
85436       {
85437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85438       };
85439     }
85440   }
85441
85442   jresult = result;
85443
85444   //argout typemap for const std::string&
85445
85446   return jresult;
85447 }
85448
85449
85450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
85451   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85452   Dali::Toolkit::Control arg2 ;
85453   std::string *arg3 = 0 ;
85454   std::string *arg4 = 0 ;
85455   Dali::Toolkit::Control *argp2 ;
85456
85457   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85458   argp2 = (Dali::Toolkit::Control *)jarg2;
85459   if (!argp2) {
85460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
85461     return ;
85462   }
85463   arg2 = *argp2;
85464   if (!jarg3) {
85465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85466     return ;
85467   }
85468   std::string arg3_str(jarg3);
85469   arg3 = &arg3_str;
85470   if (!jarg4) {
85471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85472     return ;
85473   }
85474   std::string arg4_str(jarg4);
85475   arg4 = &arg4_str;
85476   {
85477     try {
85478       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
85479     } catch (std::out_of_range& e) {
85480       {
85481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85482       };
85483     } catch (std::exception& e) {
85484       {
85485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85486       };
85487     } catch (Dali::DaliException e) {
85488       {
85489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85490       };
85491     } catch (...) {
85492       {
85493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85494       };
85495     }
85496   }
85497
85498
85499   //argout typemap for const std::string&
85500
85501
85502   //argout typemap for const std::string&
85503
85504 }
85505
85506
85507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
85508   void * jresult ;
85509   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85510   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
85511
85512   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85513   {
85514     try {
85515       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
85516     } catch (std::out_of_range& e) {
85517       {
85518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85519       };
85520     } catch (std::exception& e) {
85521       {
85522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85523       };
85524     } catch (Dali::DaliException e) {
85525       {
85526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85527       };
85528     } catch (...) {
85529       {
85530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85531       };
85532     }
85533   }
85534
85535   jresult = (void *)result;
85536   return jresult;
85537 }
85538
85539
85540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
85541   int jresult ;
85542   int result;
85543
85544   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
85545   jresult = (int)result;
85546   return jresult;
85547 }
85548
85549
85550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
85551   int jresult ;
85552   int result;
85553
85554   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
85555   jresult = (int)result;
85556   return jresult;
85557 }
85558
85559
85560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
85561   int jresult ;
85562   int result;
85563
85564   result = (int)Dali::Toolkit::Slider::Property::VALUE;
85565   jresult = (int)result;
85566   return jresult;
85567 }
85568
85569
85570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
85571   int jresult ;
85572   int result;
85573
85574   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
85575   jresult = (int)result;
85576   return jresult;
85577 }
85578
85579
85580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
85581   int jresult ;
85582   int result;
85583
85584   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
85585   jresult = (int)result;
85586   return jresult;
85587 }
85588
85589
85590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
85591   int jresult ;
85592   int result;
85593
85594   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
85595   jresult = (int)result;
85596   return jresult;
85597 }
85598
85599
85600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
85601   int jresult ;
85602   int result;
85603
85604   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
85605   jresult = (int)result;
85606   return jresult;
85607 }
85608
85609
85610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
85611   int jresult ;
85612   int result;
85613
85614   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
85615   jresult = (int)result;
85616   return jresult;
85617 }
85618
85619
85620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
85621   int jresult ;
85622   int result;
85623
85624   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
85625   jresult = (int)result;
85626   return jresult;
85627 }
85628
85629
85630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
85631   int jresult ;
85632   int result;
85633
85634   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
85635   jresult = (int)result;
85636   return jresult;
85637 }
85638
85639
85640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
85641   int jresult ;
85642   int result;
85643
85644   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
85645   jresult = (int)result;
85646   return jresult;
85647 }
85648
85649
85650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
85651   int jresult ;
85652   int result;
85653
85654   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
85655   jresult = (int)result;
85656   return jresult;
85657 }
85658
85659
85660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
85661   int jresult ;
85662   int result;
85663
85664   result = (int)Dali::Toolkit::Slider::Property::MARKS;
85665   jresult = (int)result;
85666   return jresult;
85667 }
85668
85669
85670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
85671   int jresult ;
85672   int result;
85673
85674   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
85675   jresult = (int)result;
85676   return jresult;
85677 }
85678
85679
85680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
85681   int jresult ;
85682   int result;
85683
85684   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
85685   jresult = (int)result;
85686   return jresult;
85687 }
85688
85689
85690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
85691   void * jresult ;
85692   Dali::Toolkit::Slider::Property *result = 0 ;
85693
85694   {
85695     try {
85696       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
85697     } catch (std::out_of_range& e) {
85698       {
85699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85700       };
85701     } catch (std::exception& e) {
85702       {
85703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85704       };
85705     } catch (Dali::DaliException e) {
85706       {
85707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85708       };
85709     } catch (...) {
85710       {
85711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85712       };
85713     }
85714   }
85715
85716   jresult = (void *)result;
85717   return jresult;
85718 }
85719
85720
85721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
85722   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
85723
85724   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
85725   {
85726     try {
85727       delete arg1;
85728     } catch (std::out_of_range& e) {
85729       {
85730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85731       };
85732     } catch (std::exception& e) {
85733       {
85734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85735       };
85736     } catch (Dali::DaliException e) {
85737       {
85738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85739       };
85740     } catch (...) {
85741       {
85742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85743       };
85744     }
85745   }
85746
85747 }
85748
85749
85750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
85751   void * jresult ;
85752   Dali::Toolkit::Slider result;
85753
85754   {
85755     try {
85756       result = Dali::Toolkit::Slider::New();
85757     } catch (std::out_of_range& e) {
85758       {
85759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85760       };
85761     } catch (std::exception& e) {
85762       {
85763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85764       };
85765     } catch (Dali::DaliException e) {
85766       {
85767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85768       };
85769     } catch (...) {
85770       {
85771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85772       };
85773     }
85774   }
85775
85776   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
85777   return jresult;
85778 }
85779
85780
85781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
85782   void * jresult ;
85783   Dali::Toolkit::Slider *result = 0 ;
85784
85785   {
85786     try {
85787       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
85788     } catch (std::out_of_range& e) {
85789       {
85790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85791       };
85792     } catch (std::exception& e) {
85793       {
85794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85795       };
85796     } catch (Dali::DaliException e) {
85797       {
85798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85799       };
85800     } catch (...) {
85801       {
85802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85803       };
85804     }
85805   }
85806
85807   jresult = (void *)result;
85808   return jresult;
85809 }
85810
85811
85812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
85813   void * jresult ;
85814   Dali::Toolkit::Slider *arg1 = 0 ;
85815   Dali::Toolkit::Slider *result = 0 ;
85816
85817   arg1 = (Dali::Toolkit::Slider *)jarg1;
85818   if (!arg1) {
85819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
85820     return 0;
85821   }
85822   {
85823     try {
85824       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
85825     } catch (std::out_of_range& e) {
85826       {
85827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85828       };
85829     } catch (std::exception& e) {
85830       {
85831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85832       };
85833     } catch (Dali::DaliException e) {
85834       {
85835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85836       };
85837     } catch (...) {
85838       {
85839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85840       };
85841     }
85842   }
85843
85844   jresult = (void *)result;
85845   return jresult;
85846 }
85847
85848
85849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
85850   void * jresult ;
85851   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85852   Dali::Toolkit::Slider *arg2 = 0 ;
85853   Dali::Toolkit::Slider *result = 0 ;
85854
85855   arg1 = (Dali::Toolkit::Slider *)jarg1;
85856   arg2 = (Dali::Toolkit::Slider *)jarg2;
85857   if (!arg2) {
85858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
85859     return 0;
85860   }
85861   {
85862     try {
85863       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
85864     } catch (std::out_of_range& e) {
85865       {
85866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85867       };
85868     } catch (std::exception& e) {
85869       {
85870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85871       };
85872     } catch (Dali::DaliException e) {
85873       {
85874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85875       };
85876     } catch (...) {
85877       {
85878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85879       };
85880     }
85881   }
85882
85883   jresult = (void *)result;
85884   return jresult;
85885 }
85886
85887
85888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
85889   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85890
85891   arg1 = (Dali::Toolkit::Slider *)jarg1;
85892   {
85893     try {
85894       delete arg1;
85895     } catch (std::out_of_range& e) {
85896       {
85897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85898       };
85899     } catch (std::exception& e) {
85900       {
85901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85902       };
85903     } catch (Dali::DaliException e) {
85904       {
85905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85906       };
85907     } catch (...) {
85908       {
85909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85910       };
85911     }
85912   }
85913
85914 }
85915
85916
85917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
85918   void * jresult ;
85919   Dali::BaseHandle arg1 ;
85920   Dali::BaseHandle *argp1 ;
85921   Dali::Toolkit::Slider result;
85922
85923   argp1 = (Dali::BaseHandle *)jarg1;
85924   if (!argp1) {
85925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85926     return 0;
85927   }
85928   arg1 = *argp1;
85929   {
85930     try {
85931       result = Dali::Toolkit::Slider::DownCast(arg1);
85932     } catch (std::out_of_range& e) {
85933       {
85934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85935       };
85936     } catch (std::exception& e) {
85937       {
85938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85939       };
85940     } catch (Dali::DaliException e) {
85941       {
85942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85943       };
85944     } catch (...) {
85945       {
85946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85947       };
85948     }
85949   }
85950
85951   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
85952   return jresult;
85953 }
85954
85955
85956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
85957   void * jresult ;
85958   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85959   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
85960
85961   arg1 = (Dali::Toolkit::Slider *)jarg1;
85962   {
85963     try {
85964       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
85965     } catch (std::out_of_range& e) {
85966       {
85967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85968       };
85969     } catch (std::exception& e) {
85970       {
85971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85972       };
85973     } catch (Dali::DaliException e) {
85974       {
85975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85976       };
85977     } catch (...) {
85978       {
85979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85980       };
85981     }
85982   }
85983
85984   jresult = (void *)result;
85985   return jresult;
85986 }
85987
85988
85989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
85990   void * jresult ;
85991   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85992   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
85993
85994   arg1 = (Dali::Toolkit::Slider *)jarg1;
85995   {
85996     try {
85997       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
85998     } catch (std::out_of_range& e) {
85999       {
86000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86001       };
86002     } catch (std::exception& e) {
86003       {
86004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86005       };
86006     } catch (Dali::DaliException e) {
86007       {
86008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86009       };
86010     } catch (...) {
86011       {
86012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86013       };
86014     }
86015   }
86016
86017   jresult = (void *)result;
86018   return jresult;
86019 }
86020
86021
86022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
86023   void * jresult ;
86024   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86025   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
86026
86027   arg1 = (Dali::Toolkit::Slider *)jarg1;
86028   {
86029     try {
86030       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
86031     } catch (std::out_of_range& e) {
86032       {
86033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86034       };
86035     } catch (std::exception& e) {
86036       {
86037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86038       };
86039     } catch (Dali::DaliException e) {
86040       {
86041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86042       };
86043     } catch (...) {
86044       {
86045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86046       };
86047     }
86048   }
86049
86050   jresult = (void *)result;
86051   return jresult;
86052 }
86053
86054
86055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
86056   int jresult ;
86057   int result;
86058
86059   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
86060   jresult = (int)result;
86061   return jresult;
86062 }
86063
86064
86065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
86066   int jresult ;
86067   int result;
86068
86069   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
86070   jresult = (int)result;
86071   return jresult;
86072 }
86073
86074
86075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
86076   int jresult ;
86077   int result;
86078
86079   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
86080   jresult = (int)result;
86081   return jresult;
86082 }
86083
86084
86085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
86086   int jresult ;
86087   int result;
86088
86089   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
86090   jresult = (int)result;
86091   return jresult;
86092 }
86093
86094
86095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
86096   int result;
86097
86098   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
86099
86100   return result;
86101 }
86102
86103
86104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
86105   void * jresult ;
86106   Dali::Toolkit::VideoView::Property *result = 0 ;
86107
86108   {
86109     try {
86110       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
86111     } catch (std::out_of_range& e) {
86112       {
86113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86114       };
86115     } catch (std::exception& e) {
86116       {
86117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86118       };
86119     } catch (Dali::DaliException e) {
86120       {
86121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86122       };
86123     } catch (...) {
86124       {
86125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86126       };
86127     }
86128   }
86129
86130   jresult = (void *)result;
86131   return jresult;
86132 }
86133
86134
86135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
86136   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
86137
86138   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
86139   {
86140     try {
86141       delete arg1;
86142     } catch (std::out_of_range& e) {
86143       {
86144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86145       };
86146     } catch (std::exception& e) {
86147       {
86148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86149       };
86150     } catch (Dali::DaliException e) {
86151       {
86152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86153       };
86154     } catch (...) {
86155       {
86156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86157       };
86158     }
86159   }
86160
86161 }
86162
86163
86164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
86165   void * jresult ;
86166   Dali::Toolkit::VideoView result;
86167
86168   {
86169     try {
86170       result = Dali::Toolkit::VideoView::New();
86171     } catch (std::out_of_range& e) {
86172       {
86173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86174       };
86175     } catch (std::exception& e) {
86176       {
86177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86178       };
86179     } catch (Dali::DaliException e) {
86180       {
86181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86182       };
86183     } catch (...) {
86184       {
86185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86186       };
86187     }
86188   }
86189
86190   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86191   return jresult;
86192 }
86193
86194
86195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
86196   void * jresult ;
86197   std::string *arg1 = 0 ;
86198   Dali::Toolkit::VideoView result;
86199
86200   if (!jarg1) {
86201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86202     return 0;
86203   }
86204   std::string arg1_str(jarg1);
86205   arg1 = &arg1_str;
86206   {
86207     try {
86208       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
86209     } catch (std::out_of_range& e) {
86210       {
86211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86212       };
86213     } catch (std::exception& e) {
86214       {
86215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86216       };
86217     } catch (Dali::DaliException e) {
86218       {
86219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86220       };
86221     } catch (...) {
86222       {
86223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86224       };
86225     }
86226   }
86227
86228   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86229
86230   //argout typemap for const std::string&
86231
86232   return jresult;
86233 }
86234
86235
86236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
86237   void * jresult ;
86238   Dali::Toolkit::VideoView result;
86239   {
86240     try {
86241       result = Dali::Toolkit::VideoView::New(swCodec);
86242     } catch (std::out_of_range& e) {
86243       {
86244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86245       };
86246     } catch (std::exception& e) {
86247       {
86248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86249       };
86250     } catch (Dali::DaliException e) {
86251       {
86252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86253       };
86254     } catch (...) {
86255       {
86256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86257       };
86258     }
86259   }
86260
86261   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86262
86263   //argout typemap for const std::string&
86264
86265   return jresult;
86266 }
86267
86268
86269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
86270   void * jresult ;
86271   std::string *arg1 = 0 ;
86272   Dali::Toolkit::VideoView result;
86273
86274   if (!jarg1) {
86275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86276     return 0;
86277   }
86278   std::string arg1_str(jarg1);
86279   arg1 = &arg1_str;
86280   {
86281     try {
86282       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
86283     } catch (std::out_of_range& e) {
86284       {
86285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86286       };
86287     } catch (std::exception& e) {
86288       {
86289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86290       };
86291     } catch (Dali::DaliException e) {
86292       {
86293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86294       };
86295     } catch (...) {
86296       {
86297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86298       };
86299     }
86300   }
86301
86302   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86303
86304   //argout typemap for const std::string&
86305
86306   return jresult;
86307 }
86308
86309
86310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
86311   void * jresult ;
86312   Dali::Toolkit::VideoView *result = 0 ;
86313
86314   {
86315     try {
86316       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
86317     } catch (std::out_of_range& e) {
86318       {
86319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86320       };
86321     } catch (std::exception& e) {
86322       {
86323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86324       };
86325     } catch (Dali::DaliException e) {
86326       {
86327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86328       };
86329     } catch (...) {
86330       {
86331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86332       };
86333     }
86334   }
86335
86336   jresult = (void *)result;
86337   return jresult;
86338 }
86339
86340
86341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
86342   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86343
86344   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86345   {
86346     try {
86347       delete arg1;
86348     } catch (std::out_of_range& e) {
86349       {
86350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86351       };
86352     } catch (std::exception& e) {
86353       {
86354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86355       };
86356     } catch (Dali::DaliException e) {
86357       {
86358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86359       };
86360     } catch (...) {
86361       {
86362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86363       };
86364     }
86365   }
86366
86367 }
86368
86369
86370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
86371   void * jresult ;
86372   Dali::Toolkit::VideoView *arg1 = 0 ;
86373   Dali::Toolkit::VideoView *result = 0 ;
86374
86375   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86376   if (!arg1) {
86377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
86378     return 0;
86379   }
86380   {
86381     try {
86382       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
86383     } catch (std::out_of_range& e) {
86384       {
86385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86386       };
86387     } catch (std::exception& e) {
86388       {
86389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86390       };
86391     } catch (Dali::DaliException e) {
86392       {
86393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86394       };
86395     } catch (...) {
86396       {
86397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86398       };
86399     }
86400   }
86401
86402   jresult = (void *)result;
86403   return jresult;
86404 }
86405
86406
86407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
86408   void * jresult ;
86409   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86410   Dali::Toolkit::VideoView *arg2 = 0 ;
86411   Dali::Toolkit::VideoView *result = 0 ;
86412
86413   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86414   arg2 = (Dali::Toolkit::VideoView *)jarg2;
86415   if (!arg2) {
86416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
86417     return 0;
86418   }
86419   {
86420     try {
86421       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
86422     } catch (std::out_of_range& e) {
86423       {
86424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86425       };
86426     } catch (std::exception& e) {
86427       {
86428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86429       };
86430     } catch (Dali::DaliException e) {
86431       {
86432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86433       };
86434     } catch (...) {
86435       {
86436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86437       };
86438     }
86439   }
86440
86441   jresult = (void *)result;
86442   return jresult;
86443 }
86444
86445
86446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
86447   void * jresult ;
86448   Dali::BaseHandle arg1 ;
86449   Dali::BaseHandle *argp1 ;
86450   Dali::Toolkit::VideoView result;
86451
86452   argp1 = (Dali::BaseHandle *)jarg1;
86453   if (!argp1) {
86454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86455     return 0;
86456   }
86457   arg1 = *argp1;
86458   {
86459     try {
86460       result = Dali::Toolkit::VideoView::DownCast(arg1);
86461     } catch (std::out_of_range& e) {
86462       {
86463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86464       };
86465     } catch (std::exception& e) {
86466       {
86467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86468       };
86469     } catch (Dali::DaliException e) {
86470       {
86471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86472       };
86473     } catch (...) {
86474       {
86475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86476       };
86477     }
86478   }
86479
86480   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86481   return jresult;
86482 }
86483
86484
86485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
86486   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86487
86488   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86489   {
86490     try {
86491       (arg1)->Play();
86492     } catch (std::out_of_range& e) {
86493       {
86494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86495       };
86496     } catch (std::exception& e) {
86497       {
86498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86499       };
86500     } catch (Dali::DaliException e) {
86501       {
86502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86503       };
86504     } catch (...) {
86505       {
86506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86507       };
86508     }
86509   }
86510
86511 }
86512
86513
86514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
86515   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86516
86517   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86518   {
86519     try {
86520       (arg1)->Pause();
86521     } catch (std::out_of_range& e) {
86522       {
86523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86524       };
86525     } catch (std::exception& e) {
86526       {
86527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86528       };
86529     } catch (Dali::DaliException e) {
86530       {
86531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86532       };
86533     } catch (...) {
86534       {
86535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86536       };
86537     }
86538   }
86539
86540 }
86541
86542
86543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
86544   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86545
86546   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86547   {
86548     try {
86549       (arg1)->Stop();
86550     } catch (std::out_of_range& e) {
86551       {
86552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86553       };
86554     } catch (std::exception& e) {
86555       {
86556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86557       };
86558     } catch (Dali::DaliException e) {
86559       {
86560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86561       };
86562     } catch (...) {
86563       {
86564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86565       };
86566     }
86567   }
86568
86569 }
86570
86571
86572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
86573   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86574   int arg2 ;
86575
86576   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86577   arg2 = (int)jarg2;
86578   {
86579     try {
86580       (arg1)->Forward(arg2);
86581     } catch (std::out_of_range& e) {
86582       {
86583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86584       };
86585     } catch (std::exception& e) {
86586       {
86587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86588       };
86589     } catch (Dali::DaliException e) {
86590       {
86591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86592       };
86593     } catch (...) {
86594       {
86595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86596       };
86597     }
86598   }
86599
86600 }
86601
86602
86603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
86604   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86605   int arg2 ;
86606
86607   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86608   arg2 = (int)jarg2;
86609   {
86610     try {
86611       (arg1)->Backward(arg2);
86612     } catch (std::out_of_range& e) {
86613       {
86614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86615       };
86616     } catch (std::exception& e) {
86617       {
86618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86619       };
86620     } catch (Dali::DaliException e) {
86621       {
86622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86623       };
86624     } catch (...) {
86625       {
86626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86627       };
86628     }
86629   }
86630
86631 }
86632
86633
86634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
86635   void * jresult ;
86636   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86637   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
86638
86639   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86640   {
86641     try {
86642       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
86643     } catch (std::out_of_range& e) {
86644       {
86645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86646       };
86647     } catch (std::exception& e) {
86648       {
86649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86650       };
86651     } catch (Dali::DaliException e) {
86652       {
86653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86654       };
86655     } catch (...) {
86656       {
86657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86658       };
86659     }
86660   }
86661
86662   jresult = (void *)result;
86663   return jresult;
86664 }
86665
86666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
86667 {
86668   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
86669   if( arg1 == nullptr )
86670   {
86671     DALI_LOG_ERROR("VideoView is nullptr!");
86672     return nullptr;
86673   }
86674   void * ret = nullptr;
86675   {
86676     try{
86677
86678       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
86679       ret = Dali::AnyCast< void * >( result );
86680
86681     } catch (std::out_of_range& e) {
86682       {
86683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86684       };
86685     } catch (std::exception& e) {
86686       {
86687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86688       };
86689     } catch (Dali::DaliException e) {
86690       {
86691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86692       };
86693     } catch (...) {
86694       {
86695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86696       };
86697     }
86698   }
86699   return ret;
86700 }
86701
86702
86703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
86704   int jresult ;
86705   int result;
86706
86707   result = (int)Dali::Toolkit::Popup::Property::TITLE;
86708   jresult = (int)result;
86709   return jresult;
86710 }
86711
86712
86713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
86714   int jresult ;
86715   int result;
86716
86717   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
86718   jresult = (int)result;
86719   return jresult;
86720 }
86721
86722
86723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
86724   int jresult ;
86725   int result;
86726
86727   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
86728   jresult = (int)result;
86729   return jresult;
86730 }
86731
86732
86733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
86734   int jresult ;
86735   int result;
86736
86737   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
86738   jresult = (int)result;
86739   return jresult;
86740 }
86741
86742
86743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
86744   int jresult ;
86745   int result;
86746
86747   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
86748   jresult = (int)result;
86749   return jresult;
86750 }
86751
86752
86753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
86754   int jresult ;
86755   int result;
86756
86757   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
86758   jresult = (int)result;
86759   return jresult;
86760 }
86761
86762
86763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
86764   int jresult ;
86765   int result;
86766
86767   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
86768   jresult = (int)result;
86769   return jresult;
86770 }
86771
86772
86773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
86774   int jresult ;
86775   int result;
86776
86777   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
86778   jresult = (int)result;
86779   return jresult;
86780 }
86781
86782
86783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
86784   int jresult ;
86785   int result;
86786
86787   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
86788   jresult = (int)result;
86789   return jresult;
86790 }
86791
86792
86793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
86794   int jresult ;
86795   int result;
86796
86797   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
86798   jresult = (int)result;
86799   return jresult;
86800 }
86801
86802
86803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
86804   int jresult ;
86805   int result;
86806
86807   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
86808   jresult = (int)result;
86809   return jresult;
86810 }
86811
86812
86813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
86814   int jresult ;
86815   int result;
86816
86817   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
86818   jresult = (int)result;
86819   return jresult;
86820 }
86821
86822
86823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
86824   int jresult ;
86825   int result;
86826
86827   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
86828   jresult = (int)result;
86829   return jresult;
86830 }
86831
86832
86833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
86834   int jresult ;
86835   int result;
86836
86837   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
86838   jresult = (int)result;
86839   return jresult;
86840 }
86841
86842
86843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
86844   int jresult ;
86845   int result;
86846
86847   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
86848   jresult = (int)result;
86849   return jresult;
86850 }
86851
86852
86853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
86854   int jresult ;
86855   int result;
86856
86857   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
86858   jresult = (int)result;
86859   return jresult;
86860 }
86861
86862
86863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
86864   int jresult ;
86865   int result;
86866
86867   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
86868   jresult = (int)result;
86869   return jresult;
86870 }
86871
86872
86873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
86874   int jresult ;
86875   int result;
86876
86877   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
86878   jresult = (int)result;
86879   return jresult;
86880 }
86881
86882
86883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
86884   int jresult ;
86885   int result;
86886
86887   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
86888   jresult = (int)result;
86889   return jresult;
86890 }
86891
86892
86893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
86894   int jresult ;
86895   int result;
86896
86897   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
86898   jresult = (int)result;
86899   return jresult;
86900 }
86901
86902
86903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
86904   int jresult ;
86905   int result;
86906
86907   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
86908   jresult = (int)result;
86909   return jresult;
86910 }
86911
86912
86913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
86914   void * jresult ;
86915   Dali::Toolkit::Popup::Property *result = 0 ;
86916
86917   {
86918     try {
86919       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
86920     } catch (std::out_of_range& e) {
86921       {
86922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86923       };
86924     } catch (std::exception& e) {
86925       {
86926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86927       };
86928     } catch (Dali::DaliException e) {
86929       {
86930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86931       };
86932     } catch (...) {
86933       {
86934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86935       };
86936     }
86937   }
86938
86939   jresult = (void *)result;
86940   return jresult;
86941 }
86942
86943
86944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
86945   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
86946
86947   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
86948   {
86949     try {
86950       delete arg1;
86951     } catch (std::out_of_range& e) {
86952       {
86953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86954       };
86955     } catch (std::exception& e) {
86956       {
86957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86958       };
86959     } catch (Dali::DaliException e) {
86960       {
86961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86962       };
86963     } catch (...) {
86964       {
86965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86966       };
86967     }
86968   }
86969
86970 }
86971
86972
86973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
86974   void * jresult ;
86975   Dali::Toolkit::Popup *result = 0 ;
86976
86977   {
86978     try {
86979       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
86980     } catch (std::out_of_range& e) {
86981       {
86982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86983       };
86984     } catch (std::exception& e) {
86985       {
86986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86987       };
86988     } catch (Dali::DaliException e) {
86989       {
86990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86991       };
86992     } catch (...) {
86993       {
86994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86995       };
86996     }
86997   }
86998
86999   jresult = (void *)result;
87000   return jresult;
87001 }
87002
87003
87004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
87005   void * jresult ;
87006   Dali::Toolkit::Popup result;
87007
87008   {
87009     try {
87010       result = Dali::Toolkit::Popup::New();
87011     } catch (std::out_of_range& e) {
87012       {
87013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87014       };
87015     } catch (std::exception& e) {
87016       {
87017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87018       };
87019     } catch (Dali::DaliException e) {
87020       {
87021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87022       };
87023     } catch (...) {
87024       {
87025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87026       };
87027     }
87028   }
87029
87030   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
87031   return jresult;
87032 }
87033
87034
87035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
87036   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87037
87038   arg1 = (Dali::Toolkit::Popup *)jarg1;
87039   {
87040     try {
87041       delete arg1;
87042     } catch (std::out_of_range& e) {
87043       {
87044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87045       };
87046     } catch (std::exception& e) {
87047       {
87048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87049       };
87050     } catch (Dali::DaliException e) {
87051       {
87052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87053       };
87054     } catch (...) {
87055       {
87056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87057       };
87058     }
87059   }
87060
87061 }
87062
87063
87064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
87065   void * jresult ;
87066   Dali::Toolkit::Popup *arg1 = 0 ;
87067   Dali::Toolkit::Popup *result = 0 ;
87068
87069   arg1 = (Dali::Toolkit::Popup *)jarg1;
87070   if (!arg1) {
87071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
87072     return 0;
87073   }
87074   {
87075     try {
87076       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
87077     } catch (std::out_of_range& e) {
87078       {
87079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87080       };
87081     } catch (std::exception& e) {
87082       {
87083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87084       };
87085     } catch (Dali::DaliException e) {
87086       {
87087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87088       };
87089     } catch (...) {
87090       {
87091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87092       };
87093     }
87094   }
87095
87096   jresult = (void *)result;
87097   return jresult;
87098 }
87099
87100
87101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
87102   void * jresult ;
87103   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87104   Dali::Toolkit::Popup *arg2 = 0 ;
87105   Dali::Toolkit::Popup *result = 0 ;
87106
87107   arg1 = (Dali::Toolkit::Popup *)jarg1;
87108   arg2 = (Dali::Toolkit::Popup *)jarg2;
87109   if (!arg2) {
87110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
87111     return 0;
87112   }
87113   {
87114     try {
87115       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
87116     } catch (std::out_of_range& e) {
87117       {
87118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87119       };
87120     } catch (std::exception& e) {
87121       {
87122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87123       };
87124     } catch (Dali::DaliException e) {
87125       {
87126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87127       };
87128     } catch (...) {
87129       {
87130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87131       };
87132     }
87133   }
87134
87135   jresult = (void *)result;
87136   return jresult;
87137 }
87138
87139
87140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
87141   void * jresult ;
87142   Dali::BaseHandle arg1 ;
87143   Dali::BaseHandle *argp1 ;
87144   Dali::Toolkit::Popup result;
87145
87146   argp1 = (Dali::BaseHandle *)jarg1;
87147   if (!argp1) {
87148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87149     return 0;
87150   }
87151   arg1 = *argp1;
87152   {
87153     try {
87154       result = Dali::Toolkit::Popup::DownCast(arg1);
87155     } catch (std::out_of_range& e) {
87156       {
87157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87158       };
87159     } catch (std::exception& e) {
87160       {
87161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87162       };
87163     } catch (Dali::DaliException e) {
87164       {
87165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87166       };
87167     } catch (...) {
87168       {
87169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87170       };
87171     }
87172   }
87173
87174   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
87175   return jresult;
87176 }
87177
87178
87179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
87180   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87181   Dali::Actor arg2 ;
87182   Dali::Actor *argp2 ;
87183
87184   arg1 = (Dali::Toolkit::Popup *)jarg1;
87185   argp2 = (Dali::Actor *)jarg2;
87186   if (!argp2) {
87187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87188     return ;
87189   }
87190   arg2 = *argp2;
87191   {
87192     try {
87193       (arg1)->SetTitle(arg2);
87194     } catch (std::out_of_range& e) {
87195       {
87196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87197       };
87198     } catch (std::exception& e) {
87199       {
87200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87201       };
87202     } catch (Dali::DaliException e) {
87203       {
87204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87205       };
87206     } catch (...) {
87207       {
87208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87209       };
87210     }
87211   }
87212
87213 }
87214
87215
87216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
87217   void * jresult ;
87218   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87219   Dali::Actor result;
87220
87221   arg1 = (Dali::Toolkit::Popup *)jarg1;
87222   {
87223     try {
87224       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
87225     } catch (std::out_of_range& e) {
87226       {
87227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87228       };
87229     } catch (std::exception& e) {
87230       {
87231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87232       };
87233     } catch (Dali::DaliException e) {
87234       {
87235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87236       };
87237     } catch (...) {
87238       {
87239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87240       };
87241     }
87242   }
87243
87244   jresult = new Dali::Actor((const Dali::Actor &)result);
87245   return jresult;
87246 }
87247
87248
87249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
87250   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87251   Dali::Actor arg2 ;
87252   Dali::Actor *argp2 ;
87253
87254   arg1 = (Dali::Toolkit::Popup *)jarg1;
87255   argp2 = (Dali::Actor *)jarg2;
87256   if (!argp2) {
87257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87258     return ;
87259   }
87260   arg2 = *argp2;
87261   {
87262     try {
87263       (arg1)->SetContent(arg2);
87264     } catch (std::out_of_range& e) {
87265       {
87266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87267       };
87268     } catch (std::exception& e) {
87269       {
87270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87271       };
87272     } catch (Dali::DaliException e) {
87273       {
87274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87275       };
87276     } catch (...) {
87277       {
87278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87279       };
87280     }
87281   }
87282
87283 }
87284
87285
87286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
87287   void * jresult ;
87288   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87289   Dali::Actor result;
87290
87291   arg1 = (Dali::Toolkit::Popup *)jarg1;
87292   {
87293     try {
87294       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
87295     } catch (std::out_of_range& e) {
87296       {
87297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87298       };
87299     } catch (std::exception& e) {
87300       {
87301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87302       };
87303     } catch (Dali::DaliException e) {
87304       {
87305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87306       };
87307     } catch (...) {
87308       {
87309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87310       };
87311     }
87312   }
87313
87314   jresult = new Dali::Actor((const Dali::Actor &)result);
87315   return jresult;
87316 }
87317
87318
87319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
87320   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87321   Dali::Actor arg2 ;
87322   Dali::Actor *argp2 ;
87323
87324   arg1 = (Dali::Toolkit::Popup *)jarg1;
87325   argp2 = (Dali::Actor *)jarg2;
87326   if (!argp2) {
87327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87328     return ;
87329   }
87330   arg2 = *argp2;
87331   {
87332     try {
87333       (arg1)->SetFooter(arg2);
87334     } catch (std::out_of_range& e) {
87335       {
87336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87337       };
87338     } catch (std::exception& e) {
87339       {
87340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87341       };
87342     } catch (Dali::DaliException e) {
87343       {
87344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87345       };
87346     } catch (...) {
87347       {
87348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87349       };
87350     }
87351   }
87352
87353 }
87354
87355
87356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
87357   void * jresult ;
87358   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87359   Dali::Actor result;
87360
87361   arg1 = (Dali::Toolkit::Popup *)jarg1;
87362   {
87363     try {
87364       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
87365     } catch (std::out_of_range& e) {
87366       {
87367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87368       };
87369     } catch (std::exception& e) {
87370       {
87371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87372       };
87373     } catch (Dali::DaliException e) {
87374       {
87375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87376       };
87377     } catch (...) {
87378       {
87379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87380       };
87381     }
87382   }
87383
87384   jresult = new Dali::Actor((const Dali::Actor &)result);
87385   return jresult;
87386 }
87387
87388
87389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
87390   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87391   Dali::Toolkit::Popup::DisplayState arg2 ;
87392
87393   arg1 = (Dali::Toolkit::Popup *)jarg1;
87394   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
87395   {
87396     try {
87397       (arg1)->SetDisplayState(arg2);
87398     } catch (std::out_of_range& e) {
87399       {
87400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87401       };
87402     } catch (std::exception& e) {
87403       {
87404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87405       };
87406     } catch (Dali::DaliException e) {
87407       {
87408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87409       };
87410     } catch (...) {
87411       {
87412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87413       };
87414     }
87415   }
87416
87417 }
87418
87419
87420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
87421   int jresult ;
87422   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87423   Dali::Toolkit::Popup::DisplayState result;
87424
87425   arg1 = (Dali::Toolkit::Popup *)jarg1;
87426   {
87427     try {
87428       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
87429     } catch (std::out_of_range& e) {
87430       {
87431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87432       };
87433     } catch (std::exception& e) {
87434       {
87435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87436       };
87437     } catch (Dali::DaliException e) {
87438       {
87439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87440       };
87441     } catch (...) {
87442       {
87443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87444       };
87445     }
87446   }
87447
87448   jresult = (int)result;
87449   return jresult;
87450 }
87451
87452
87453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
87454   void * jresult ;
87455   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87456   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
87457
87458   arg1 = (Dali::Toolkit::Popup *)jarg1;
87459   {
87460     try {
87461       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
87462     } catch (std::out_of_range& e) {
87463       {
87464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87465       };
87466     } catch (std::exception& e) {
87467       {
87468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87469       };
87470     } catch (Dali::DaliException e) {
87471       {
87472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87473       };
87474     } catch (...) {
87475       {
87476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87477       };
87478     }
87479   }
87480
87481   jresult = (void *)result;
87482   return jresult;
87483 }
87484
87485
87486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
87487   void * jresult ;
87488   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87489   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87490
87491   arg1 = (Dali::Toolkit::Popup *)jarg1;
87492   {
87493     try {
87494       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
87495     } catch (std::out_of_range& e) {
87496       {
87497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87498       };
87499     } catch (std::exception& e) {
87500       {
87501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87502       };
87503     } catch (Dali::DaliException e) {
87504       {
87505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87506       };
87507     } catch (...) {
87508       {
87509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87510       };
87511     }
87512   }
87513
87514   jresult = (void *)result;
87515   return jresult;
87516 }
87517
87518
87519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
87520   void * jresult ;
87521   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87522   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87523
87524   arg1 = (Dali::Toolkit::Popup *)jarg1;
87525   {
87526     try {
87527       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
87528     } catch (std::out_of_range& e) {
87529       {
87530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87531       };
87532     } catch (std::exception& e) {
87533       {
87534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87535       };
87536     } catch (Dali::DaliException e) {
87537       {
87538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87539       };
87540     } catch (...) {
87541       {
87542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87543       };
87544     }
87545   }
87546
87547   jresult = (void *)result;
87548   return jresult;
87549 }
87550
87551
87552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
87553   void * jresult ;
87554   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87555   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87556
87557   arg1 = (Dali::Toolkit::Popup *)jarg1;
87558   {
87559     try {
87560       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
87561     } catch (std::out_of_range& e) {
87562       {
87563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87564       };
87565     } catch (std::exception& e) {
87566       {
87567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87568       };
87569     } catch (Dali::DaliException e) {
87570       {
87571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87572       };
87573     } catch (...) {
87574       {
87575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87576       };
87577     }
87578   }
87579
87580   jresult = (void *)result;
87581   return jresult;
87582 }
87583
87584
87585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
87586   void * jresult ;
87587   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87588   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87589
87590   arg1 = (Dali::Toolkit::Popup *)jarg1;
87591   {
87592     try {
87593       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
87594     } catch (std::out_of_range& e) {
87595       {
87596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87597       };
87598     } catch (std::exception& e) {
87599       {
87600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87601       };
87602     } catch (Dali::DaliException e) {
87603       {
87604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87605       };
87606     } catch (...) {
87607       {
87608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87609       };
87610     }
87611   }
87612
87613   jresult = (void *)result;
87614   return jresult;
87615 }
87616
87617
87618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
87619   int jresult ;
87620   int result;
87621
87622   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
87623   jresult = (int)result;
87624   return jresult;
87625 }
87626
87627
87628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
87629   int jresult ;
87630   int result;
87631
87632   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
87633   jresult = (int)result;
87634   return jresult;
87635 }
87636
87637
87638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
87639   int jresult ;
87640   int result;
87641
87642   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
87643   jresult = (int)result;
87644   return jresult;
87645 }
87646
87647
87648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
87649   int jresult ;
87650   int result;
87651
87652   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
87653   jresult = (int)result;
87654   return jresult;
87655 }
87656
87657
87658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
87659   int jresult ;
87660   int result;
87661
87662   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
87663   jresult = (int)result;
87664   return jresult;
87665 }
87666
87667
87668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
87669   int jresult ;
87670   int result;
87671
87672   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
87673   jresult = (int)result;
87674   return jresult;
87675 }
87676
87677
87678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
87679   int jresult ;
87680   int result;
87681
87682   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
87683   jresult = (int)result;
87684   return jresult;
87685 }
87686
87687
87688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
87689   int jresult ;
87690   int result;
87691
87692   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
87693   jresult = (int)result;
87694   return jresult;
87695 }
87696
87697
87698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
87699   int jresult ;
87700   int result;
87701
87702   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
87703   jresult = (int)result;
87704   return jresult;
87705 }
87706
87707
87708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
87709   void * jresult ;
87710   Dali::Toolkit::ProgressBar::Property *result = 0 ;
87711
87712   {
87713     try {
87714       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
87715     } catch (std::out_of_range& e) {
87716       {
87717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87718       };
87719     } catch (std::exception& e) {
87720       {
87721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87722       };
87723     } catch (Dali::DaliException e) {
87724       {
87725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87726       };
87727     } catch (...) {
87728       {
87729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87730       };
87731     }
87732   }
87733
87734   jresult = (void *)result;
87735   return jresult;
87736 }
87737
87738
87739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
87740   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
87741
87742   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
87743   {
87744     try {
87745       delete arg1;
87746     } catch (std::out_of_range& e) {
87747       {
87748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87749       };
87750     } catch (std::exception& e) {
87751       {
87752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87753       };
87754     } catch (Dali::DaliException e) {
87755       {
87756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87757       };
87758     } catch (...) {
87759       {
87760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87761       };
87762     }
87763   }
87764
87765 }
87766
87767
87768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
87769   void * jresult ;
87770   Dali::Toolkit::ProgressBar result;
87771
87772   {
87773     try {
87774       result = Dali::Toolkit::ProgressBar::New();
87775     } catch (std::out_of_range& e) {
87776       {
87777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87778       };
87779     } catch (std::exception& e) {
87780       {
87781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87782       };
87783     } catch (Dali::DaliException e) {
87784       {
87785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87786       };
87787     } catch (...) {
87788       {
87789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87790       };
87791     }
87792   }
87793
87794   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
87795   return jresult;
87796 }
87797
87798
87799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
87800   void * jresult ;
87801   Dali::Toolkit::ProgressBar *result = 0 ;
87802
87803   {
87804     try {
87805       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
87806     } catch (std::out_of_range& e) {
87807       {
87808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87809       };
87810     } catch (std::exception& e) {
87811       {
87812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87813       };
87814     } catch (Dali::DaliException e) {
87815       {
87816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87817       };
87818     } catch (...) {
87819       {
87820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87821       };
87822     }
87823   }
87824
87825   jresult = (void *)result;
87826   return jresult;
87827 }
87828
87829
87830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
87831   void * jresult ;
87832   Dali::Toolkit::ProgressBar *arg1 = 0 ;
87833   Dali::Toolkit::ProgressBar *result = 0 ;
87834
87835   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87836   if (!arg1) {
87837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
87838     return 0;
87839   }
87840   {
87841     try {
87842       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
87843     } catch (std::out_of_range& e) {
87844       {
87845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87846       };
87847     } catch (std::exception& e) {
87848       {
87849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87850       };
87851     } catch (Dali::DaliException e) {
87852       {
87853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87854       };
87855     } catch (...) {
87856       {
87857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87858       };
87859     }
87860   }
87861
87862   jresult = (void *)result;
87863   return jresult;
87864 }
87865
87866
87867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
87868   void * jresult ;
87869   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87870   Dali::Toolkit::ProgressBar *arg2 = 0 ;
87871   Dali::Toolkit::ProgressBar *result = 0 ;
87872
87873   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87874   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
87875   if (!arg2) {
87876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
87877     return 0;
87878   }
87879   {
87880     try {
87881       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
87882     } catch (std::out_of_range& e) {
87883       {
87884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87885       };
87886     } catch (std::exception& e) {
87887       {
87888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87889       };
87890     } catch (Dali::DaliException e) {
87891       {
87892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87893       };
87894     } catch (...) {
87895       {
87896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87897       };
87898     }
87899   }
87900
87901   jresult = (void *)result;
87902   return jresult;
87903 }
87904
87905
87906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
87907   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87908
87909   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87910   {
87911     try {
87912       delete arg1;
87913     } catch (std::out_of_range& e) {
87914       {
87915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87916       };
87917     } catch (std::exception& e) {
87918       {
87919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87920       };
87921     } catch (Dali::DaliException e) {
87922       {
87923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87924       };
87925     } catch (...) {
87926       {
87927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87928       };
87929     }
87930   }
87931
87932 }
87933
87934
87935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
87936   void * jresult ;
87937   Dali::BaseHandle arg1 ;
87938   Dali::BaseHandle *argp1 ;
87939   Dali::Toolkit::ProgressBar result;
87940
87941   argp1 = (Dali::BaseHandle *)jarg1;
87942   if (!argp1) {
87943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87944     return 0;
87945   }
87946   arg1 = *argp1;
87947   {
87948     try {
87949       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
87950     } catch (std::out_of_range& e) {
87951       {
87952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87953       };
87954     } catch (std::exception& e) {
87955       {
87956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87957       };
87958     } catch (Dali::DaliException e) {
87959       {
87960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87961       };
87962     } catch (...) {
87963       {
87964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87965       };
87966     }
87967   }
87968
87969   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
87970   return jresult;
87971 }
87972
87973
87974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
87975   void * jresult ;
87976   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87977   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
87978
87979   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87980   {
87981     try {
87982       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87983     } catch (std::out_of_range& e) {
87984       {
87985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87986       };
87987     } catch (std::exception& e) {
87988       {
87989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87990       };
87991     } catch (Dali::DaliException e) {
87992       {
87993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87994       };
87995     } catch (...) {
87996       {
87997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87998       };
87999     }
88000   }
88001
88002   jresult = (void *)result;
88003   return jresult;
88004 }
88005
88006
88007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
88008   void * jresult ;
88009   Dali::Toolkit::GaussianBlurView *result = 0 ;
88010
88011   {
88012     try {
88013       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
88014     } catch (std::out_of_range& e) {
88015       {
88016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88017       };
88018     } catch (std::exception& e) {
88019       {
88020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88021       };
88022     } catch (Dali::DaliException e) {
88023       {
88024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88025       };
88026     } catch (...) {
88027       {
88028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88029       };
88030     }
88031   }
88032
88033   jresult = (void *)result;
88034   return jresult;
88035 }
88036
88037
88038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
88039   void * jresult ;
88040   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
88041   Dali::Toolkit::GaussianBlurView *result = 0 ;
88042
88043   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88044   if (!arg1) {
88045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
88046     return 0;
88047   }
88048   {
88049     try {
88050       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
88051     } catch (std::out_of_range& e) {
88052       {
88053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88054       };
88055     } catch (std::exception& e) {
88056       {
88057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88058       };
88059     } catch (Dali::DaliException e) {
88060       {
88061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88062       };
88063     } catch (...) {
88064       {
88065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88066       };
88067     }
88068   }
88069
88070   jresult = (void *)result;
88071   return jresult;
88072 }
88073
88074
88075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
88076   void * jresult ;
88077   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88078   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
88079   Dali::Toolkit::GaussianBlurView *result = 0 ;
88080
88081   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88082   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
88083   if (!arg2) {
88084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
88085     return 0;
88086   }
88087   {
88088     try {
88089       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
88090     } catch (std::out_of_range& e) {
88091       {
88092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88093       };
88094     } catch (std::exception& e) {
88095       {
88096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88097       };
88098     } catch (Dali::DaliException e) {
88099       {
88100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88101       };
88102     } catch (...) {
88103       {
88104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88105       };
88106     }
88107   }
88108
88109   jresult = (void *)result;
88110   return jresult;
88111 }
88112
88113
88114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
88115   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88116
88117   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88118   {
88119     try {
88120       delete arg1;
88121     } catch (std::out_of_range& e) {
88122       {
88123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88124       };
88125     } catch (std::exception& e) {
88126       {
88127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88128       };
88129     } catch (Dali::DaliException e) {
88130       {
88131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88132       };
88133     } catch (...) {
88134       {
88135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88136       };
88137     }
88138   }
88139
88140 }
88141
88142
88143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
88144   void * jresult ;
88145   Dali::BaseHandle arg1 ;
88146   Dali::BaseHandle *argp1 ;
88147   Dali::Toolkit::GaussianBlurView result;
88148
88149   argp1 = (Dali::BaseHandle *)jarg1;
88150   if (!argp1) {
88151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88152     return 0;
88153   }
88154   arg1 = *argp1;
88155   {
88156     try {
88157       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
88158     } catch (std::out_of_range& e) {
88159       {
88160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88161       };
88162     } catch (std::exception& e) {
88163       {
88164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88165       };
88166     } catch (Dali::DaliException e) {
88167       {
88168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88169       };
88170     } catch (...) {
88171       {
88172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88173       };
88174     }
88175   }
88176
88177   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88178   return jresult;
88179 }
88180
88181
88182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
88183   void * jresult ;
88184   Dali::Toolkit::GaussianBlurView result;
88185
88186   {
88187     try {
88188       result = Dali::Toolkit::GaussianBlurView::New();
88189     } catch (std::out_of_range& e) {
88190       {
88191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88192       };
88193     } catch (std::exception& e) {
88194       {
88195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88196       };
88197     } catch (Dali::DaliException e) {
88198       {
88199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88200       };
88201     } catch (...) {
88202       {
88203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88204       };
88205     }
88206   }
88207
88208   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88209   return jresult;
88210 }
88211
88212
88213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
88214   void * jresult ;
88215   unsigned int arg1 ;
88216   float arg2 ;
88217   Dali::Pixel::Format arg3 ;
88218   float arg4 ;
88219   float arg5 ;
88220   bool arg6 ;
88221   Dali::Toolkit::GaussianBlurView result;
88222
88223   arg1 = (unsigned int)jarg1;
88224   arg2 = (float)jarg2;
88225   arg3 = (Dali::Pixel::Format)jarg3;
88226   arg4 = (float)jarg4;
88227   arg5 = (float)jarg5;
88228   arg6 = jarg6 ? true : false;
88229   {
88230     try {
88231       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
88232     } catch (std::out_of_range& e) {
88233       {
88234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88235       };
88236     } catch (std::exception& e) {
88237       {
88238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88239       };
88240     } catch (Dali::DaliException e) {
88241       {
88242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88243       };
88244     } catch (...) {
88245       {
88246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88247       };
88248     }
88249   }
88250
88251   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88252   return jresult;
88253 }
88254
88255
88256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
88257   void * jresult ;
88258   unsigned int arg1 ;
88259   float arg2 ;
88260   Dali::Pixel::Format arg3 ;
88261   float arg4 ;
88262   float arg5 ;
88263   Dali::Toolkit::GaussianBlurView result;
88264
88265   arg1 = (unsigned int)jarg1;
88266   arg2 = (float)jarg2;
88267   arg3 = (Dali::Pixel::Format)jarg3;
88268   arg4 = (float)jarg4;
88269   arg5 = (float)jarg5;
88270   {
88271     try {
88272       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
88273     } catch (std::out_of_range& e) {
88274       {
88275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88276       };
88277     } catch (std::exception& e) {
88278       {
88279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88280       };
88281     } catch (Dali::DaliException e) {
88282       {
88283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88284       };
88285     } catch (...) {
88286       {
88287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88288       };
88289     }
88290   }
88291
88292   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88293   return jresult;
88294 }
88295
88296
88297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
88298   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88299   Dali::Actor arg2 ;
88300   Dali::Actor *argp2 ;
88301
88302   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88303   argp2 = (Dali::Actor *)jarg2;
88304   if (!argp2) {
88305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88306     return ;
88307   }
88308   arg2 = *argp2;
88309   {
88310     try {
88311       (arg1)->Add(arg2);
88312     } catch (std::out_of_range& e) {
88313       {
88314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88315       };
88316     } catch (std::exception& e) {
88317       {
88318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88319       };
88320     } catch (Dali::DaliException e) {
88321       {
88322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88323       };
88324     } catch (...) {
88325       {
88326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88327       };
88328     }
88329   }
88330
88331 }
88332
88333
88334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
88335   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88336   Dali::Actor arg2 ;
88337   Dali::Actor *argp2 ;
88338
88339   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88340   argp2 = (Dali::Actor *)jarg2;
88341   if (!argp2) {
88342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88343     return ;
88344   }
88345   arg2 = *argp2;
88346   {
88347     try {
88348       (arg1)->Remove(arg2);
88349     } catch (std::out_of_range& e) {
88350       {
88351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88352       };
88353     } catch (std::exception& e) {
88354       {
88355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88356       };
88357     } catch (Dali::DaliException e) {
88358       {
88359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88360       };
88361     } catch (...) {
88362       {
88363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88364       };
88365     }
88366   }
88367
88368 }
88369
88370
88371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
88372   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88373
88374   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88375   {
88376     try {
88377       (arg1)->Activate();
88378     } catch (std::out_of_range& e) {
88379       {
88380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88381       };
88382     } catch (std::exception& e) {
88383       {
88384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88385       };
88386     } catch (Dali::DaliException e) {
88387       {
88388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88389       };
88390     } catch (...) {
88391       {
88392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88393       };
88394     }
88395   }
88396
88397 }
88398
88399
88400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
88401   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88402
88403   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88404   {
88405     try {
88406       (arg1)->ActivateOnce();
88407     } catch (std::out_of_range& e) {
88408       {
88409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88410       };
88411     } catch (std::exception& e) {
88412       {
88413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88414       };
88415     } catch (Dali::DaliException e) {
88416       {
88417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88418       };
88419     } catch (...) {
88420       {
88421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88422       };
88423     }
88424   }
88425
88426 }
88427
88428
88429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
88430   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88431
88432   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88433   {
88434     try {
88435       (arg1)->Deactivate();
88436     } catch (std::out_of_range& e) {
88437       {
88438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88439       };
88440     } catch (std::exception& e) {
88441       {
88442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88443       };
88444     } catch (Dali::DaliException e) {
88445       {
88446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88447       };
88448     } catch (...) {
88449       {
88450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88451       };
88452     }
88453   }
88454
88455 }
88456
88457
88458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
88459   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88460   Dali::Texture arg2 ;
88461   Dali::FrameBuffer arg3 ;
88462   Dali::Texture *argp2 ;
88463   Dali::FrameBuffer *argp3 ;
88464
88465   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88466   argp2 = (Dali::Texture *)jarg2;
88467   if (!argp2) {
88468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
88469     return ;
88470   }
88471   arg2 = *argp2;
88472   argp3 = (Dali::FrameBuffer *)jarg3;
88473   if (!argp3) {
88474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
88475     return ;
88476   }
88477   arg3 = *argp3;
88478   {
88479     try {
88480       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
88481     } catch (std::out_of_range& e) {
88482       {
88483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88484       };
88485     } catch (std::exception& e) {
88486       {
88487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88488       };
88489     } catch (Dali::DaliException e) {
88490       {
88491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88492       };
88493     } catch (...) {
88494       {
88495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88496       };
88497     }
88498   }
88499
88500 }
88501
88502
88503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
88504   int jresult ;
88505   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88506   Dali::Property::Index result;
88507
88508   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88509   {
88510     try {
88511       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
88512     } catch (std::out_of_range& e) {
88513       {
88514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88515       };
88516     } catch (std::exception& e) {
88517       {
88518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88519       };
88520     } catch (Dali::DaliException e) {
88521       {
88522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88523       };
88524     } catch (...) {
88525       {
88526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88527       };
88528     }
88529   }
88530
88531   jresult = result;
88532   return jresult;
88533 }
88534
88535
88536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
88537   void * jresult ;
88538   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88539   Dali::FrameBuffer result;
88540
88541   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88542   {
88543     try {
88544       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
88545     } catch (std::out_of_range& e) {
88546       {
88547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88548       };
88549     } catch (std::exception& e) {
88550       {
88551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88552       };
88553     } catch (Dali::DaliException e) {
88554       {
88555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88556       };
88557     } catch (...) {
88558       {
88559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88560       };
88561     }
88562   }
88563
88564   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
88565   return jresult;
88566 }
88567
88568
88569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
88570   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88571   Dali::Vector4 *arg2 = 0 ;
88572
88573   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88574   arg2 = (Dali::Vector4 *)jarg2;
88575   if (!arg2) {
88576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
88577     return ;
88578   }
88579   {
88580     try {
88581       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
88582     } catch (std::out_of_range& e) {
88583       {
88584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88585       };
88586     } catch (std::exception& e) {
88587       {
88588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88589       };
88590     } catch (Dali::DaliException e) {
88591       {
88592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88593       };
88594     } catch (...) {
88595       {
88596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88597       };
88598     }
88599   }
88600
88601 }
88602
88603
88604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
88605   void * jresult ;
88606   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88607   Dali::Vector4 result;
88608
88609   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88610   {
88611     try {
88612       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
88613     } catch (std::out_of_range& e) {
88614       {
88615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88616       };
88617     } catch (std::exception& e) {
88618       {
88619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88620       };
88621     } catch (Dali::DaliException e) {
88622       {
88623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88624       };
88625     } catch (...) {
88626       {
88627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88628       };
88629     }
88630   }
88631
88632   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
88633   return jresult;
88634 }
88635
88636
88637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
88638   void * jresult ;
88639   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88640   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
88641
88642   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88643   {
88644     try {
88645       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
88646     } catch (std::out_of_range& e) {
88647       {
88648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88649       };
88650     } catch (std::exception& e) {
88651       {
88652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88653       };
88654     } catch (Dali::DaliException e) {
88655       {
88656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88657       };
88658     } catch (...) {
88659       {
88660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88661       };
88662     }
88663   }
88664
88665   jresult = (void *)result;
88666   return jresult;
88667 }
88668
88669
88670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
88671   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88672
88673   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88674   {
88675     try {
88676       delete arg1;
88677     } catch (std::out_of_range& e) {
88678       {
88679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88680       };
88681     } catch (std::exception& e) {
88682       {
88683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88684       };
88685     } catch (Dali::DaliException e) {
88686       {
88687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88688       };
88689     } catch (...) {
88690       {
88691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88692       };
88693     }
88694   }
88695
88696 }
88697
88698
88699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
88700   unsigned int jresult ;
88701   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88702   unsigned int result;
88703
88704   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88705   {
88706     try {
88707       result = (unsigned int)(arg1)->GetNumberOfPages();
88708     } catch (std::out_of_range& e) {
88709       {
88710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88711       };
88712     } catch (std::exception& e) {
88713       {
88714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88715       };
88716     } catch (Dali::DaliException e) {
88717       {
88718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88719       };
88720     } catch (...) {
88721       {
88722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88723       };
88724     }
88725   }
88726
88727   jresult = result;
88728   return jresult;
88729 }
88730
88731
88732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
88733   void * jresult ;
88734   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88735   unsigned int arg2 ;
88736   Dali::Texture result;
88737
88738   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88739   arg2 = (unsigned int)jarg2;
88740   {
88741     try {
88742       result = (arg1)->NewPage(arg2);
88743     } catch (std::out_of_range& e) {
88744       {
88745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88746       };
88747     } catch (std::exception& e) {
88748       {
88749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88750       };
88751     } catch (Dali::DaliException e) {
88752       {
88753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88754       };
88755     } catch (...) {
88756       {
88757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88758       };
88759     }
88760   }
88761
88762   jresult = new Dali::Texture((const Dali::Texture &)result);
88763   return jresult;
88764 }
88765
88766
88767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
88768   int jresult ;
88769   int result;
88770
88771   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
88772   jresult = (int)result;
88773   return jresult;
88774 }
88775
88776
88777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
88778   int jresult ;
88779   int result;
88780
88781   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
88782   jresult = (int)result;
88783   return jresult;
88784 }
88785
88786
88787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
88788   int jresult ;
88789   int result;
88790
88791   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
88792   jresult = (int)result;
88793   return jresult;
88794 }
88795
88796
88797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
88798   void * jresult ;
88799   Dali::Toolkit::PageTurnView::Property *result = 0 ;
88800
88801   {
88802     try {
88803       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
88804     } catch (std::out_of_range& e) {
88805       {
88806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88807       };
88808     } catch (std::exception& e) {
88809       {
88810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88811       };
88812     } catch (Dali::DaliException e) {
88813       {
88814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88815       };
88816     } catch (...) {
88817       {
88818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88819       };
88820     }
88821   }
88822
88823   jresult = (void *)result;
88824   return jresult;
88825 }
88826
88827
88828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
88829   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
88830
88831   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
88832   {
88833     try {
88834       delete arg1;
88835     } catch (std::out_of_range& e) {
88836       {
88837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88838       };
88839     } catch (std::exception& e) {
88840       {
88841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88842       };
88843     } catch (Dali::DaliException e) {
88844       {
88845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88846       };
88847     } catch (...) {
88848       {
88849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88850       };
88851     }
88852   }
88853
88854 }
88855
88856
88857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
88858   void * jresult ;
88859   Dali::Toolkit::PageTurnView *result = 0 ;
88860
88861   {
88862     try {
88863       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
88864     } catch (std::out_of_range& e) {
88865       {
88866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88867       };
88868     } catch (std::exception& e) {
88869       {
88870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88871       };
88872     } catch (Dali::DaliException e) {
88873       {
88874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88875       };
88876     } catch (...) {
88877       {
88878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88879       };
88880     }
88881   }
88882
88883   jresult = (void *)result;
88884   return jresult;
88885 }
88886
88887
88888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
88889   void * jresult ;
88890   Dali::Toolkit::PageTurnView *arg1 = 0 ;
88891   Dali::Toolkit::PageTurnView *result = 0 ;
88892
88893   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88894   if (!arg1) {
88895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
88896     return 0;
88897   }
88898   {
88899     try {
88900       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
88901     } catch (std::out_of_range& e) {
88902       {
88903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88904       };
88905     } catch (std::exception& e) {
88906       {
88907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88908       };
88909     } catch (Dali::DaliException e) {
88910       {
88911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88912       };
88913     } catch (...) {
88914       {
88915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88916       };
88917     }
88918   }
88919
88920   jresult = (void *)result;
88921   return jresult;
88922 }
88923
88924
88925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
88926   void * jresult ;
88927   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88928   Dali::Toolkit::PageTurnView *arg2 = 0 ;
88929   Dali::Toolkit::PageTurnView *result = 0 ;
88930
88931   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88932   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
88933   if (!arg2) {
88934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
88935     return 0;
88936   }
88937   {
88938     try {
88939       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
88940     } catch (std::out_of_range& e) {
88941       {
88942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88943       };
88944     } catch (std::exception& e) {
88945       {
88946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88947       };
88948     } catch (Dali::DaliException e) {
88949       {
88950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88951       };
88952     } catch (...) {
88953       {
88954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88955       };
88956     }
88957   }
88958
88959   jresult = (void *)result;
88960   return jresult;
88961 }
88962
88963
88964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
88965   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88966
88967   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88968   {
88969     try {
88970       delete arg1;
88971     } catch (std::out_of_range& e) {
88972       {
88973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88974       };
88975     } catch (std::exception& e) {
88976       {
88977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88978       };
88979     } catch (Dali::DaliException e) {
88980       {
88981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88982       };
88983     } catch (...) {
88984       {
88985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88986       };
88987     }
88988   }
88989
88990 }
88991
88992
88993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
88994   void * jresult ;
88995   Dali::BaseHandle arg1 ;
88996   Dali::BaseHandle *argp1 ;
88997   Dali::Toolkit::PageTurnView result;
88998
88999   argp1 = (Dali::BaseHandle *)jarg1;
89000   if (!argp1) {
89001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89002     return 0;
89003   }
89004   arg1 = *argp1;
89005   {
89006     try {
89007       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
89008     } catch (std::out_of_range& e) {
89009       {
89010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89011       };
89012     } catch (std::exception& e) {
89013       {
89014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89015       };
89016     } catch (Dali::DaliException e) {
89017       {
89018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89019       };
89020     } catch (...) {
89021       {
89022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89023       };
89024     }
89025   }
89026
89027   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
89028   return jresult;
89029 }
89030
89031
89032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
89033   void * jresult ;
89034   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89035   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
89036
89037   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89038   {
89039     try {
89040       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
89041     } catch (std::out_of_range& e) {
89042       {
89043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89044       };
89045     } catch (std::exception& e) {
89046       {
89047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89048       };
89049     } catch (Dali::DaliException e) {
89050       {
89051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89052       };
89053     } catch (...) {
89054       {
89055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89056       };
89057     }
89058   }
89059
89060   jresult = (void *)result;
89061   return jresult;
89062 }
89063
89064
89065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
89066   void * jresult ;
89067   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89068   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
89069
89070   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89071   {
89072     try {
89073       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
89074     } catch (std::out_of_range& e) {
89075       {
89076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89077       };
89078     } catch (std::exception& e) {
89079       {
89080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89081       };
89082     } catch (Dali::DaliException e) {
89083       {
89084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89085       };
89086     } catch (...) {
89087       {
89088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89089       };
89090     }
89091   }
89092
89093   jresult = (void *)result;
89094   return jresult;
89095 }
89096
89097
89098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
89099   void * jresult ;
89100   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89101   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
89102
89103   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89104   {
89105     try {
89106       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
89107     } catch (std::out_of_range& e) {
89108       {
89109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89110       };
89111     } catch (std::exception& e) {
89112       {
89113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89114       };
89115     } catch (Dali::DaliException e) {
89116       {
89117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89118       };
89119     } catch (...) {
89120       {
89121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89122       };
89123     }
89124   }
89125
89126   jresult = (void *)result;
89127   return jresult;
89128 }
89129
89130
89131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
89132   void * jresult ;
89133   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89134   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
89135
89136   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89137   {
89138     try {
89139       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
89140     } catch (std::out_of_range& e) {
89141       {
89142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89143       };
89144     } catch (std::exception& e) {
89145       {
89146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89147       };
89148     } catch (Dali::DaliException e) {
89149       {
89150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89151       };
89152     } catch (...) {
89153       {
89154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89155       };
89156     }
89157   }
89158
89159   jresult = (void *)result;
89160   return jresult;
89161 }
89162
89163
89164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
89165   void * jresult ;
89166   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89167
89168   {
89169     try {
89170       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
89171     } catch (std::out_of_range& e) {
89172       {
89173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89174       };
89175     } catch (std::exception& e) {
89176       {
89177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89178       };
89179     } catch (Dali::DaliException e) {
89180       {
89181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89182       };
89183     } catch (...) {
89184       {
89185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89186       };
89187     }
89188   }
89189
89190   jresult = (void *)result;
89191   return jresult;
89192 }
89193
89194
89195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
89196   void * jresult ;
89197   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
89198   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89199
89200   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89201   if (!arg1) {
89202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89203     return 0;
89204   }
89205   {
89206     try {
89207       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
89208     } catch (std::out_of_range& e) {
89209       {
89210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89211       };
89212     } catch (std::exception& e) {
89213       {
89214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89215       };
89216     } catch (Dali::DaliException e) {
89217       {
89218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89219       };
89220     } catch (...) {
89221       {
89222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89223       };
89224     }
89225   }
89226
89227   jresult = (void *)result;
89228   return jresult;
89229 }
89230
89231
89232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
89233   void * jresult ;
89234   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
89235   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
89236   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89237
89238   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89239   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
89240   if (!arg2) {
89241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89242     return 0;
89243   }
89244   {
89245     try {
89246       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
89247     } catch (std::out_of_range& e) {
89248       {
89249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89250       };
89251     } catch (std::exception& e) {
89252       {
89253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89254       };
89255     } catch (Dali::DaliException e) {
89256       {
89257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89258       };
89259     } catch (...) {
89260       {
89261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89262       };
89263     }
89264   }
89265
89266   jresult = (void *)result;
89267   return jresult;
89268 }
89269
89270
89271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
89272   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
89273
89274   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89275   {
89276     try {
89277       delete arg1;
89278     } catch (std::out_of_range& e) {
89279       {
89280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89281       };
89282     } catch (std::exception& e) {
89283       {
89284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89285       };
89286     } catch (Dali::DaliException e) {
89287       {
89288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89289       };
89290     } catch (...) {
89291       {
89292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89293       };
89294     }
89295   }
89296
89297 }
89298
89299
89300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
89301   void * jresult ;
89302   Dali::Toolkit::PageFactory *arg1 = 0 ;
89303   Dali::Vector2 *arg2 = 0 ;
89304   Dali::Toolkit::PageTurnLandscapeView result;
89305
89306   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89307   if (!arg1) {
89308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
89309     return 0;
89310   }
89311   arg2 = (Dali::Vector2 *)jarg2;
89312   if (!arg2) {
89313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
89314     return 0;
89315   }
89316   {
89317     try {
89318       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
89319     } catch (std::out_of_range& e) {
89320       {
89321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89322       };
89323     } catch (std::exception& e) {
89324       {
89325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89326       };
89327     } catch (Dali::DaliException e) {
89328       {
89329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89330       };
89331     } catch (...) {
89332       {
89333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89334       };
89335     }
89336   }
89337
89338   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
89339   return jresult;
89340 }
89341
89342
89343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
89344   void * jresult ;
89345   Dali::BaseHandle arg1 ;
89346   Dali::BaseHandle *argp1 ;
89347   Dali::Toolkit::PageTurnLandscapeView result;
89348
89349   argp1 = (Dali::BaseHandle *)jarg1;
89350   if (!argp1) {
89351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89352     return 0;
89353   }
89354   arg1 = *argp1;
89355   {
89356     try {
89357       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
89358     } catch (std::out_of_range& e) {
89359       {
89360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89361       };
89362     } catch (std::exception& e) {
89363       {
89364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89365       };
89366     } catch (Dali::DaliException e) {
89367       {
89368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89369       };
89370     } catch (...) {
89371       {
89372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89373       };
89374     }
89375   }
89376
89377   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
89378   return jresult;
89379 }
89380
89381
89382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
89383   void * jresult ;
89384   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89385
89386   {
89387     try {
89388       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
89389     } catch (std::out_of_range& e) {
89390       {
89391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89392       };
89393     } catch (std::exception& e) {
89394       {
89395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89396       };
89397     } catch (Dali::DaliException e) {
89398       {
89399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89400       };
89401     } catch (...) {
89402       {
89403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89404       };
89405     }
89406   }
89407
89408   jresult = (void *)result;
89409   return jresult;
89410 }
89411
89412
89413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
89414   void * jresult ;
89415   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
89416   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89417
89418   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89419   if (!arg1) {
89420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
89421     return 0;
89422   }
89423   {
89424     try {
89425       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
89426     } catch (std::out_of_range& e) {
89427       {
89428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89429       };
89430     } catch (std::exception& e) {
89431       {
89432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89433       };
89434     } catch (Dali::DaliException e) {
89435       {
89436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89437       };
89438     } catch (...) {
89439       {
89440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89441       };
89442     }
89443   }
89444
89445   jresult = (void *)result;
89446   return jresult;
89447 }
89448
89449
89450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
89451   void * jresult ;
89452   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
89453   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
89454   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89455
89456   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89457   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
89458   if (!arg2) {
89459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
89460     return 0;
89461   }
89462   {
89463     try {
89464       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
89465     } catch (std::out_of_range& e) {
89466       {
89467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89468       };
89469     } catch (std::exception& e) {
89470       {
89471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89472       };
89473     } catch (Dali::DaliException e) {
89474       {
89475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89476       };
89477     } catch (...) {
89478       {
89479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89480       };
89481     }
89482   }
89483
89484   jresult = (void *)result;
89485   return jresult;
89486 }
89487
89488
89489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
89490   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
89491
89492   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89493   {
89494     try {
89495       delete arg1;
89496     } catch (std::out_of_range& e) {
89497       {
89498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89499       };
89500     } catch (std::exception& e) {
89501       {
89502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89503       };
89504     } catch (Dali::DaliException e) {
89505       {
89506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89507       };
89508     } catch (...) {
89509       {
89510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89511       };
89512     }
89513   }
89514
89515 }
89516
89517
89518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
89519   void * jresult ;
89520   Dali::Toolkit::PageFactory *arg1 = 0 ;
89521   Dali::Vector2 *arg2 = 0 ;
89522   Dali::Toolkit::PageTurnPortraitView result;
89523
89524   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89525   if (!arg1) {
89526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
89527     return 0;
89528   }
89529   arg2 = (Dali::Vector2 *)jarg2;
89530   if (!arg2) {
89531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
89532     return 0;
89533   }
89534   {
89535     try {
89536       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
89537     } catch (std::out_of_range& e) {
89538       {
89539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89540       };
89541     } catch (std::exception& e) {
89542       {
89543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89544       };
89545     } catch (Dali::DaliException e) {
89546       {
89547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89548       };
89549     } catch (...) {
89550       {
89551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89552       };
89553     }
89554   }
89555
89556   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
89557   return jresult;
89558 }
89559
89560
89561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
89562   void * jresult ;
89563   Dali::BaseHandle arg1 ;
89564   Dali::BaseHandle *argp1 ;
89565   Dali::Toolkit::PageTurnPortraitView result;
89566
89567   argp1 = (Dali::BaseHandle *)jarg1;
89568   if (!argp1) {
89569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89570     return 0;
89571   }
89572   arg1 = *argp1;
89573   {
89574     try {
89575       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
89576     } catch (std::out_of_range& e) {
89577       {
89578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89579       };
89580     } catch (std::exception& e) {
89581       {
89582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89583       };
89584     } catch (Dali::DaliException e) {
89585       {
89586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89587       };
89588     } catch (...) {
89589       {
89590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89591       };
89592     }
89593   }
89594
89595   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
89596   return jresult;
89597 }
89598
89599
89600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
89601   int jresult ;
89602   int result;
89603
89604   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
89605   jresult = (int)result;
89606   return jresult;
89607 }
89608
89609
89610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
89611   int jresult ;
89612   int result;
89613
89614   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
89615   jresult = (int)result;
89616   return jresult;
89617 }
89618
89619
89620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
89621   int jresult ;
89622   int result;
89623
89624   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
89625   jresult = (int)result;
89626   return jresult;
89627 }
89628
89629
89630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
89631   void * jresult ;
89632   Dali::Toolkit::ToggleButton::Property *result = 0 ;
89633
89634   {
89635     try {
89636       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
89637     } catch (std::out_of_range& e) {
89638       {
89639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89640       };
89641     } catch (std::exception& e) {
89642       {
89643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89644       };
89645     } catch (Dali::DaliException e) {
89646       {
89647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89648       };
89649     } catch (...) {
89650       {
89651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89652       };
89653     }
89654   }
89655
89656   jresult = (void *)result;
89657   return jresult;
89658 }
89659
89660
89661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
89662   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
89663
89664   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
89665   {
89666     try {
89667       delete arg1;
89668     } catch (std::out_of_range& e) {
89669       {
89670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89671       };
89672     } catch (std::exception& e) {
89673       {
89674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89675       };
89676     } catch (Dali::DaliException e) {
89677       {
89678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89679       };
89680     } catch (...) {
89681       {
89682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89683       };
89684     }
89685   }
89686
89687 }
89688
89689
89690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
89691   void * jresult ;
89692   Dali::Toolkit::ToggleButton *result = 0 ;
89693
89694   {
89695     try {
89696       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
89697     } catch (std::out_of_range& e) {
89698       {
89699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89700       };
89701     } catch (std::exception& e) {
89702       {
89703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89704       };
89705     } catch (Dali::DaliException e) {
89706       {
89707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89708       };
89709     } catch (...) {
89710       {
89711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89712       };
89713     }
89714   }
89715
89716   jresult = (void *)result;
89717   return jresult;
89718 }
89719
89720
89721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
89722   void * jresult ;
89723   Dali::Toolkit::ToggleButton *arg1 = 0 ;
89724   Dali::Toolkit::ToggleButton *result = 0 ;
89725
89726   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89727   if (!arg1) {
89728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
89729     return 0;
89730   }
89731   {
89732     try {
89733       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
89734     } catch (std::out_of_range& e) {
89735       {
89736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89737       };
89738     } catch (std::exception& e) {
89739       {
89740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89741       };
89742     } catch (Dali::DaliException e) {
89743       {
89744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89745       };
89746     } catch (...) {
89747       {
89748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89749       };
89750     }
89751   }
89752
89753   jresult = (void *)result;
89754   return jresult;
89755 }
89756
89757
89758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
89759   void * jresult ;
89760   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
89761   Dali::Toolkit::ToggleButton *arg2 = 0 ;
89762   Dali::Toolkit::ToggleButton *result = 0 ;
89763
89764   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89765   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
89766   if (!arg2) {
89767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
89768     return 0;
89769   }
89770   {
89771     try {
89772       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
89773     } catch (std::out_of_range& e) {
89774       {
89775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89776       };
89777     } catch (std::exception& e) {
89778       {
89779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89780       };
89781     } catch (Dali::DaliException e) {
89782       {
89783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89784       };
89785     } catch (...) {
89786       {
89787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89788       };
89789     }
89790   }
89791
89792   jresult = (void *)result;
89793   return jresult;
89794 }
89795
89796
89797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
89798   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
89799
89800   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89801   {
89802     try {
89803       delete arg1;
89804     } catch (std::out_of_range& e) {
89805       {
89806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89807       };
89808     } catch (std::exception& e) {
89809       {
89810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89811       };
89812     } catch (Dali::DaliException e) {
89813       {
89814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89815       };
89816     } catch (...) {
89817       {
89818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89819       };
89820     }
89821   }
89822
89823 }
89824
89825
89826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
89827   void * jresult ;
89828   Dali::Toolkit::ToggleButton result;
89829
89830   {
89831     try {
89832       result = Dali::Toolkit::ToggleButton::New();
89833     } catch (std::out_of_range& e) {
89834       {
89835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89836       };
89837     } catch (std::exception& e) {
89838       {
89839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89840       };
89841     } catch (Dali::DaliException e) {
89842       {
89843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89844       };
89845     } catch (...) {
89846       {
89847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89848       };
89849     }
89850   }
89851
89852   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
89853   return jresult;
89854 }
89855
89856
89857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
89858   void * jresult ;
89859   Dali::BaseHandle arg1 ;
89860   Dali::BaseHandle *argp1 ;
89861   Dali::Toolkit::ToggleButton result;
89862
89863   argp1 = (Dali::BaseHandle *)jarg1;
89864   if (!argp1) {
89865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89866     return 0;
89867   }
89868   arg1 = *argp1;
89869   {
89870     try {
89871       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
89872     } catch (std::out_of_range& e) {
89873       {
89874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89875       };
89876     } catch (std::exception& e) {
89877       {
89878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89879       };
89880     } catch (Dali::DaliException e) {
89881       {
89882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89883       };
89884     } catch (...) {
89885       {
89886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89887       };
89888     }
89889   }
89890
89891   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
89892   return jresult;
89893 }
89894
89895
89896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
89897   void * jresult ;
89898   Dali::Toolkit::Visual::Base *result = 0 ;
89899
89900   {
89901     try {
89902       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
89903     } catch (std::out_of_range& e) {
89904       {
89905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89906       };
89907     } catch (std::exception& e) {
89908       {
89909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89910       };
89911     } catch (Dali::DaliException e) {
89912       {
89913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89914       };
89915     } catch (...) {
89916       {
89917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89918       };
89919     }
89920   }
89921
89922   jresult = (void *)result;
89923   return jresult;
89924 }
89925
89926
89927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
89928   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89929
89930   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89931   {
89932     try {
89933       delete arg1;
89934     } catch (std::out_of_range& e) {
89935       {
89936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89937       };
89938     } catch (std::exception& e) {
89939       {
89940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89941       };
89942     } catch (Dali::DaliException e) {
89943       {
89944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89945       };
89946     } catch (...) {
89947       {
89948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89949       };
89950     }
89951   }
89952
89953 }
89954
89955
89956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
89957   void * jresult ;
89958   Dali::Toolkit::Visual::Base *arg1 = 0 ;
89959   Dali::Toolkit::Visual::Base *result = 0 ;
89960
89961   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89962   if (!arg1) {
89963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
89964     return 0;
89965   }
89966   {
89967     try {
89968       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
89969     } catch (std::out_of_range& e) {
89970       {
89971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89972       };
89973     } catch (std::exception& e) {
89974       {
89975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89976       };
89977     } catch (Dali::DaliException e) {
89978       {
89979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89980       };
89981     } catch (...) {
89982       {
89983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89984       };
89985     }
89986   }
89987
89988   jresult = (void *)result;
89989   return jresult;
89990 }
89991
89992
89993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
89994   void * jresult ;
89995   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89996   Dali::Toolkit::Visual::Base *arg2 = 0 ;
89997   Dali::Toolkit::Visual::Base *result = 0 ;
89998
89999   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90000   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
90001   if (!arg2) {
90002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
90003     return 0;
90004   }
90005   {
90006     try {
90007       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
90008     } catch (std::out_of_range& e) {
90009       {
90010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90011       };
90012     } catch (std::exception& e) {
90013       {
90014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90015       };
90016     } catch (Dali::DaliException e) {
90017       {
90018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90019       };
90020     } catch (...) {
90021       {
90022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90023       };
90024     }
90025   }
90026
90027   jresult = (void *)result;
90028   return jresult;
90029 }
90030
90031
90032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
90033   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90034   std::string *arg2 = 0 ;
90035
90036   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90037   if (!jarg2) {
90038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90039     return ;
90040   }
90041   std::string arg2_str(jarg2);
90042   arg2 = &arg2_str;
90043   {
90044     try {
90045       (arg1)->SetName((std::string const &)*arg2);
90046     } catch (std::out_of_range& e) {
90047       {
90048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90049       };
90050     } catch (std::exception& e) {
90051       {
90052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90053       };
90054     } catch (Dali::DaliException e) {
90055       {
90056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90057       };
90058     } catch (...) {
90059       {
90060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90061       };
90062     }
90063   }
90064
90065
90066   //argout typemap for const std::string&
90067
90068 }
90069
90070
90071 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
90072   char * jresult ;
90073   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90074   std::string *result = 0 ;
90075
90076   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90077   {
90078     try {
90079       result = (std::string *) &(arg1)->GetName();
90080     } catch (std::out_of_range& e) {
90081       {
90082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90083       };
90084     } catch (std::exception& e) {
90085       {
90086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90087       };
90088     } catch (Dali::DaliException e) {
90089       {
90090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90091       };
90092     } catch (...) {
90093       {
90094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90095       };
90096     }
90097   }
90098
90099   jresult = SWIG_csharp_string_callback(result->c_str());
90100   return jresult;
90101 }
90102
90103
90104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
90105   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90106   Dali::Property::Map *arg2 = 0 ;
90107   Dali::Size arg3 ;
90108   Dali::Size *argp3 ;
90109
90110   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90111   arg2 = (Dali::Property::Map *)jarg2;
90112   if (!arg2) {
90113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
90114     return ;
90115   }
90116   argp3 = (Dali::Size *)jarg3;
90117   if (!argp3) {
90118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
90119     return ;
90120   }
90121   arg3 = *argp3;
90122   {
90123     try {
90124       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
90125     } catch (std::out_of_range& e) {
90126       {
90127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90128       };
90129     } catch (std::exception& e) {
90130       {
90131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90132       };
90133     } catch (Dali::DaliException e) {
90134       {
90135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90136       };
90137     } catch (...) {
90138       {
90139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90140       };
90141     }
90142   }
90143
90144 }
90145
90146
90147 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
90148   float jresult ;
90149   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90150   float arg2 ;
90151   float result;
90152
90153   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90154   arg2 = (float)jarg2;
90155   {
90156     try {
90157       result = (float)(arg1)->GetHeightForWidth(arg2);
90158     } catch (std::out_of_range& e) {
90159       {
90160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90161       };
90162     } catch (std::exception& e) {
90163       {
90164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90165       };
90166     } catch (Dali::DaliException e) {
90167       {
90168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90169       };
90170     } catch (...) {
90171       {
90172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90173       };
90174     }
90175   }
90176
90177   jresult = result;
90178   return jresult;
90179 }
90180
90181
90182 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
90183   float jresult ;
90184   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90185   float arg2 ;
90186   float result;
90187
90188   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90189   arg2 = (float)jarg2;
90190   {
90191     try {
90192       result = (float)(arg1)->GetWidthForHeight(arg2);
90193     } catch (std::out_of_range& e) {
90194       {
90195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90196       };
90197     } catch (std::exception& e) {
90198       {
90199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90200       };
90201     } catch (Dali::DaliException e) {
90202       {
90203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90204       };
90205     } catch (...) {
90206       {
90207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90208       };
90209     }
90210   }
90211
90212   jresult = result;
90213   return jresult;
90214 }
90215
90216
90217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
90218   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90219   Dali::Vector2 *arg2 = 0 ;
90220
90221   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90222   arg2 = (Dali::Vector2 *)jarg2;
90223   if (!arg2) {
90224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
90225     return ;
90226   }
90227   {
90228     try {
90229       (arg1)->GetNaturalSize(*arg2);
90230     } catch (std::out_of_range& e) {
90231       {
90232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90233       };
90234     } catch (std::exception& e) {
90235       {
90236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90237       };
90238     } catch (Dali::DaliException e) {
90239       {
90240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90241       };
90242     } catch (...) {
90243       {
90244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90245       };
90246     }
90247   }
90248
90249 }
90250
90251
90252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
90253   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90254   float arg2 ;
90255
90256   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90257   arg2 = (int)jarg2;
90258   {
90259     try {
90260       (arg1)->SetDepthIndex(arg2);
90261     } catch (std::out_of_range& e) {
90262       {
90263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90264       };
90265     } catch (std::exception& e) {
90266       {
90267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90268       };
90269     } catch (Dali::DaliException e) {
90270       {
90271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90272       };
90273     } catch (...) {
90274       {
90275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90276       };
90277     }
90278   }
90279
90280 }
90281
90282
90283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
90284   int jresult ;
90285   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90286   int result;
90287
90288   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90289   {
90290     try {
90291       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
90292     } catch (std::out_of_range& e) {
90293       {
90294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90295       };
90296     } catch (std::exception& e) {
90297       {
90298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90299       };
90300     } catch (Dali::DaliException e) {
90301       {
90302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90303       };
90304     } catch (...) {
90305       {
90306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90307       };
90308     }
90309   }
90310
90311   jresult = result;
90312   return jresult;
90313 }
90314
90315
90316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
90317   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90318   Dali::Property::Map *arg2 = 0 ;
90319
90320   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90321   arg2 = (Dali::Property::Map *)jarg2;
90322   if (!arg2) {
90323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
90324     return ;
90325   }
90326   {
90327     try {
90328       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
90329     } catch (std::out_of_range& e) {
90330       {
90331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90332       };
90333     } catch (std::exception& e) {
90334       {
90335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90336       };
90337     } catch (Dali::DaliException e) {
90338       {
90339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90340       };
90341     } catch (...) {
90342       {
90343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90344       };
90345     }
90346   }
90347
90348 }
90349
90350
90351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
90352   void * jresult ;
90353   Dali::Toolkit::VisualFactory result;
90354
90355   {
90356     try {
90357       result = Dali::Toolkit::VisualFactory::Get();
90358     } catch (std::out_of_range& e) {
90359       {
90360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90361       };
90362     } catch (std::exception& e) {
90363       {
90364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90365       };
90366     } catch (Dali::DaliException e) {
90367       {
90368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90369       };
90370     } catch (...) {
90371       {
90372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90373       };
90374     }
90375   }
90376
90377   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
90378   return jresult;
90379 }
90380
90381
90382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
90383   void * jresult ;
90384   Dali::Toolkit::VisualFactory *result = 0 ;
90385
90386   {
90387     try {
90388       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
90389     } catch (std::out_of_range& e) {
90390       {
90391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90392       };
90393     } catch (std::exception& e) {
90394       {
90395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90396       };
90397     } catch (Dali::DaliException e) {
90398       {
90399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90400       };
90401     } catch (...) {
90402       {
90403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90404       };
90405     }
90406   }
90407
90408   jresult = (void *)result;
90409   return jresult;
90410 }
90411
90412
90413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
90414   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90415
90416   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90417   {
90418     try {
90419       delete arg1;
90420     } catch (std::out_of_range& e) {
90421       {
90422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90423       };
90424     } catch (std::exception& e) {
90425       {
90426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90427       };
90428     } catch (Dali::DaliException e) {
90429       {
90430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90431       };
90432     } catch (...) {
90433       {
90434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90435       };
90436     }
90437   }
90438
90439 }
90440
90441
90442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
90443   void * jresult ;
90444   Dali::Toolkit::VisualFactory *arg1 = 0 ;
90445   Dali::Toolkit::VisualFactory *result = 0 ;
90446
90447   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90448   if (!arg1) {
90449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
90450     return 0;
90451   }
90452   {
90453     try {
90454       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
90455     } catch (std::out_of_range& e) {
90456       {
90457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90458       };
90459     } catch (std::exception& e) {
90460       {
90461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90462       };
90463     } catch (Dali::DaliException e) {
90464       {
90465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90466       };
90467     } catch (...) {
90468       {
90469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90470       };
90471     }
90472   }
90473
90474   jresult = (void *)result;
90475   return jresult;
90476 }
90477
90478
90479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
90480   void * jresult ;
90481   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90482   Dali::Toolkit::VisualFactory *arg2 = 0 ;
90483   Dali::Toolkit::VisualFactory *result = 0 ;
90484
90485   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90486   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
90487   if (!arg2) {
90488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
90489     return 0;
90490   }
90491   {
90492     try {
90493       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
90494     } catch (std::out_of_range& e) {
90495       {
90496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90497       };
90498     } catch (std::exception& e) {
90499       {
90500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90501       };
90502     } catch (Dali::DaliException e) {
90503       {
90504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90505       };
90506     } catch (...) {
90507       {
90508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90509       };
90510     }
90511   }
90512
90513   jresult = (void *)result;
90514   return jresult;
90515 }
90516
90517
90518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
90519   void * jresult ;
90520   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90521   Dali::Property::Map *arg2 = 0 ;
90522   Dali::Toolkit::Visual::Base result;
90523
90524   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90525   arg2 = (Dali::Property::Map *)jarg2;
90526   if (!arg2) {
90527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
90528     return 0;
90529   }
90530   {
90531     try {
90532       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
90533     } catch (std::out_of_range& e) {
90534       {
90535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90536       };
90537     } catch (std::exception& e) {
90538       {
90539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90540       };
90541     } catch (Dali::DaliException e) {
90542       {
90543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90544       };
90545     } catch (...) {
90546       {
90547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90548       };
90549     }
90550   }
90551
90552   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90553   return jresult;
90554 }
90555
90556
90557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
90558   void * jresult ;
90559   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90560   Dali::Image *arg2 = 0 ;
90561   Dali::Toolkit::Visual::Base result;
90562
90563   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90564   arg2 = (Dali::Image *)jarg2;
90565   if (!arg2) {
90566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
90567     return 0;
90568   }
90569   {
90570     try {
90571       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
90572     } catch (std::out_of_range& e) {
90573       {
90574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90575       };
90576     } catch (std::exception& e) {
90577       {
90578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90579       };
90580     } catch (Dali::DaliException e) {
90581       {
90582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90583       };
90584     } catch (...) {
90585       {
90586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90587       };
90588     }
90589   }
90590
90591   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90592   return jresult;
90593 }
90594
90595
90596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
90597   void * jresult ;
90598   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90599   std::string *arg2 = 0 ;
90600   Dali::ImageDimensions arg3 ;
90601   Dali::ImageDimensions *argp3 ;
90602   Dali::Toolkit::Visual::Base result;
90603
90604   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90605   if (!jarg2) {
90606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90607     return 0;
90608   }
90609   std::string arg2_str(jarg2);
90610   arg2 = &arg2_str;
90611   argp3 = (Dali::ImageDimensions *)jarg3;
90612   if (!argp3) {
90613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90614     return 0;
90615   }
90616   arg3 = *argp3;
90617   {
90618     try {
90619       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
90620     } catch (std::out_of_range& e) {
90621       {
90622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90623       };
90624     } catch (std::exception& e) {
90625       {
90626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90627       };
90628     } catch (Dali::DaliException e) {
90629       {
90630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90631       };
90632     } catch (...) {
90633       {
90634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90635       };
90636     }
90637   }
90638
90639   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90640
90641   //argout typemap for const std::string&
90642
90643   return jresult;
90644 }
90645
90646
90647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
90648   void * jresult ;
90649   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90650
90651   {
90652     try {
90653       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
90654     } catch (std::out_of_range& e) {
90655       {
90656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90657       };
90658     } catch (std::exception& e) {
90659       {
90660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90661       };
90662     } catch (Dali::DaliException e) {
90663       {
90664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90665       };
90666     } catch (...) {
90667       {
90668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90669       };
90670     }
90671   }
90672
90673   jresult = (void *)result;
90674   return jresult;
90675 }
90676
90677
90678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
90679   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90680
90681   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90682   {
90683     try {
90684       delete arg1;
90685     } catch (std::out_of_range& e) {
90686       {
90687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90688       };
90689     } catch (std::exception& e) {
90690       {
90691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90692       };
90693     } catch (Dali::DaliException e) {
90694       {
90695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90696       };
90697     } catch (...) {
90698       {
90699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90700       };
90701     }
90702   }
90703
90704 }
90705
90706
90707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
90708   void * jresult ;
90709   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
90710   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90711
90712   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90713   if (!arg1) {
90714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
90715     return 0;
90716   }
90717   {
90718     try {
90719       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
90720     } catch (std::out_of_range& e) {
90721       {
90722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90723       };
90724     } catch (std::exception& e) {
90725       {
90726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90727       };
90728     } catch (Dali::DaliException e) {
90729       {
90730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90731       };
90732     } catch (...) {
90733       {
90734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90735       };
90736     }
90737   }
90738
90739   jresult = (void *)result;
90740   return jresult;
90741 }
90742
90743
90744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
90745   void * jresult ;
90746   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90747   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
90748   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90749
90750   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90751   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
90752   if (!arg2) {
90753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
90754     return 0;
90755   }
90756   {
90757     try {
90758       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
90759     } catch (std::out_of_range& e) {
90760       {
90761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90762       };
90763     } catch (std::exception& e) {
90764       {
90765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90766       };
90767     } catch (Dali::DaliException e) {
90768       {
90769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90770       };
90771     } catch (...) {
90772       {
90773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90774       };
90775     }
90776   }
90777
90778   jresult = (void *)result;
90779   return jresult;
90780 }
90781
90782
90783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
90784   void * jresult ;
90785   Dali::Toolkit::AsyncImageLoader result;
90786
90787   {
90788     try {
90789       result = Dali::Toolkit::AsyncImageLoader::New();
90790     } catch (std::out_of_range& e) {
90791       {
90792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90793       };
90794     } catch (std::exception& e) {
90795       {
90796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90797       };
90798     } catch (Dali::DaliException e) {
90799       {
90800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90801       };
90802     } catch (...) {
90803       {
90804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90805       };
90806     }
90807   }
90808
90809   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
90810   return jresult;
90811 }
90812
90813
90814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
90815   void * jresult ;
90816   Dali::BaseHandle arg1 ;
90817   Dali::BaseHandle *argp1 ;
90818   Dali::Toolkit::AsyncImageLoader result;
90819
90820   argp1 = (Dali::BaseHandle *)jarg1;
90821   if (!argp1) {
90822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90823     return 0;
90824   }
90825   arg1 = *argp1;
90826   {
90827     try {
90828       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
90829     } catch (std::out_of_range& e) {
90830       {
90831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90832       };
90833     } catch (std::exception& e) {
90834       {
90835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90836       };
90837     } catch (Dali::DaliException e) {
90838       {
90839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90840       };
90841     } catch (...) {
90842       {
90843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90844       };
90845     }
90846   }
90847
90848   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
90849   return jresult;
90850 }
90851
90852
90853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
90854   unsigned int jresult ;
90855   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90856   std::string *arg2 = 0 ;
90857   uint32_t result;
90858
90859   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90860   if (!jarg2) {
90861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90862     return 0;
90863   }
90864   std::string arg2_str(jarg2);
90865   arg2 = &arg2_str;
90866   {
90867     try {
90868       result = (arg1)->Load((std::string const &)*arg2);
90869     } catch (std::out_of_range& e) {
90870       {
90871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90872       };
90873     } catch (std::exception& e) {
90874       {
90875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90876       };
90877     } catch (Dali::DaliException e) {
90878       {
90879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90880       };
90881     } catch (...) {
90882       {
90883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90884       };
90885     }
90886   }
90887
90888   jresult = result;
90889
90890   //argout typemap for const std::string&
90891
90892   return jresult;
90893 }
90894
90895
90896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
90897   unsigned int jresult ;
90898   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90899   std::string *arg2 = 0 ;
90900   Dali::ImageDimensions arg3 ;
90901   Dali::ImageDimensions *argp3 ;
90902   uint32_t result;
90903
90904   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90905   if (!jarg2) {
90906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90907     return 0;
90908   }
90909   std::string arg2_str(jarg2);
90910   arg2 = &arg2_str;
90911   argp3 = (Dali::ImageDimensions *)jarg3;
90912   if (!argp3) {
90913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90914     return 0;
90915   }
90916   arg3 = *argp3;
90917   {
90918     try {
90919       result = (arg1)->Load((std::string const &)*arg2,arg3);
90920     } catch (std::out_of_range& e) {
90921       {
90922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90923       };
90924     } catch (std::exception& e) {
90925       {
90926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90927       };
90928     } catch (Dali::DaliException e) {
90929       {
90930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90931       };
90932     } catch (...) {
90933       {
90934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90935       };
90936     }
90937   }
90938
90939   jresult = result;
90940
90941   //argout typemap for const std::string&
90942
90943   return jresult;
90944 }
90945
90946
90947 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
90948   unsigned int jresult ;
90949   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90950   std::string *arg2 = 0 ;
90951   Dali::ImageDimensions arg3 ;
90952   Dali::FittingMode::Type arg4 ;
90953   Dali::SamplingMode::Type arg5 ;
90954   bool arg6 ;
90955   Dali::ImageDimensions *argp3 ;
90956   uint32_t result;
90957
90958   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90959   if (!jarg2) {
90960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90961     return 0;
90962   }
90963   std::string arg2_str(jarg2);
90964   arg2 = &arg2_str;
90965   argp3 = (Dali::ImageDimensions *)jarg3;
90966   if (!argp3) {
90967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90968     return 0;
90969   }
90970   arg3 = *argp3;
90971   arg4 = (Dali::FittingMode::Type)jarg4;
90972   arg5 = (Dali::SamplingMode::Type)jarg5;
90973   arg6 = jarg6 ? true : false;
90974   {
90975     try {
90976       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
90977     } catch (std::out_of_range& e) {
90978       {
90979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90980       };
90981     } catch (std::exception& e) {
90982       {
90983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90984       };
90985     } catch (Dali::DaliException e) {
90986       {
90987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90988       };
90989     } catch (...) {
90990       {
90991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90992       };
90993     }
90994   }
90995
90996   jresult = result;
90997
90998   //argout typemap for const std::string&
90999
91000   return jresult;
91001 }
91002
91003
91004 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
91005   unsigned int jresult ;
91006   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91007   uint32_t arg2 ;
91008   bool result;
91009
91010   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91011   arg2 = (uint32_t)jarg2;
91012   {
91013     try {
91014       result = (bool)(arg1)->Cancel(arg2);
91015     } catch (std::out_of_range& e) {
91016       {
91017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91018       };
91019     } catch (std::exception& e) {
91020       {
91021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91022       };
91023     } catch (Dali::DaliException e) {
91024       {
91025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91026       };
91027     } catch (...) {
91028       {
91029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91030       };
91031     }
91032   }
91033
91034   jresult = result;
91035   return jresult;
91036 }
91037
91038
91039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
91040   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91041
91042   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91043   {
91044     try {
91045       (arg1)->CancelAll();
91046     } catch (std::out_of_range& e) {
91047       {
91048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91049       };
91050     } catch (std::exception& e) {
91051       {
91052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91053       };
91054     } catch (Dali::DaliException e) {
91055       {
91056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91057       };
91058     } catch (...) {
91059       {
91060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91061       };
91062     }
91063   }
91064
91065 }
91066
91067
91068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
91069   void * jresult ;
91070   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91071   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
91072
91073   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91074   {
91075     try {
91076       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
91077     } catch (std::out_of_range& e) {
91078       {
91079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91080       };
91081     } catch (std::exception& e) {
91082       {
91083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91084       };
91085     } catch (Dali::DaliException e) {
91086       {
91087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91088       };
91089     } catch (...) {
91090       {
91091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91092       };
91093     }
91094   }
91095
91096   jresult = (void *)result;
91097   return jresult;
91098 }
91099
91100
91101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
91102   void * jresult ;
91103   std::string *arg1 = 0 ;
91104   Dali::PixelData result;
91105
91106   if (!jarg1) {
91107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91108     return 0;
91109   }
91110   std::string arg1_str(jarg1);
91111   arg1 = &arg1_str;
91112   {
91113     try {
91114       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
91115     } catch (std::out_of_range& e) {
91116       {
91117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91118       };
91119     } catch (std::exception& e) {
91120       {
91121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91122       };
91123     } catch (Dali::DaliException e) {
91124       {
91125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91126       };
91127     } catch (...) {
91128       {
91129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91130       };
91131     }
91132   }
91133
91134   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91135
91136   //argout typemap for const std::string&
91137
91138   return jresult;
91139 }
91140
91141
91142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
91143   void * jresult ;
91144   std::string *arg1 = 0 ;
91145   Dali::ImageDimensions arg2 ;
91146   Dali::ImageDimensions *argp2 ;
91147   Dali::PixelData result;
91148
91149   if (!jarg1) {
91150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91151     return 0;
91152   }
91153   std::string arg1_str(jarg1);
91154   arg1 = &arg1_str;
91155   argp2 = (Dali::ImageDimensions *)jarg2;
91156   if (!argp2) {
91157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91158     return 0;
91159   }
91160   arg2 = *argp2;
91161   {
91162     try {
91163       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
91164     } catch (std::out_of_range& e) {
91165       {
91166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91167       };
91168     } catch (std::exception& e) {
91169       {
91170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91171       };
91172     } catch (Dali::DaliException e) {
91173       {
91174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91175       };
91176     } catch (...) {
91177       {
91178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91179       };
91180     }
91181   }
91182
91183   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91184
91185   //argout typemap for const std::string&
91186
91187   return jresult;
91188 }
91189
91190
91191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
91192   void * jresult ;
91193   std::string *arg1 = 0 ;
91194   Dali::ImageDimensions arg2 ;
91195   Dali::FittingMode::Type arg3 ;
91196   Dali::SamplingMode::Type arg4 ;
91197   bool arg5 ;
91198   Dali::ImageDimensions *argp2 ;
91199   Dali::PixelData result;
91200
91201   if (!jarg1) {
91202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91203     return 0;
91204   }
91205   std::string arg1_str(jarg1);
91206   arg1 = &arg1_str;
91207   argp2 = (Dali::ImageDimensions *)jarg2;
91208   if (!argp2) {
91209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91210     return 0;
91211   }
91212   arg2 = *argp2;
91213   arg3 = (Dali::FittingMode::Type)jarg3;
91214   arg4 = (Dali::SamplingMode::Type)jarg4;
91215   arg5 = jarg5 ? true : false;
91216   {
91217     try {
91218       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
91219     } catch (std::out_of_range& e) {
91220       {
91221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91222       };
91223     } catch (std::exception& e) {
91224       {
91225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91226       };
91227     } catch (Dali::DaliException e) {
91228       {
91229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91230       };
91231     } catch (...) {
91232       {
91233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91234       };
91235     }
91236   }
91237
91238   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91239
91240   //argout typemap for const std::string&
91241
91242   return jresult;
91243 }
91244
91245
91246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
91247   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
91248
91249   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
91250   {
91251     try {
91252       delete arg1;
91253     } catch (std::out_of_range& e) {
91254       {
91255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91256       };
91257     } catch (std::exception& e) {
91258       {
91259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91260       };
91261     } catch (Dali::DaliException e) {
91262       {
91263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91264       };
91265     } catch (...) {
91266       {
91267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91268       };
91269     }
91270   }
91271
91272 }
91273
91274
91275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
91276   void * jresult ;
91277   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
91278   Dali::Actor arg2 ;
91279   Dali::Actor arg3 ;
91280   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
91281   Dali::Actor *argp2 ;
91282   Dali::Actor *argp3 ;
91283   Dali::Actor result;
91284
91285   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
91286   argp2 = (Dali::Actor *)jarg2;
91287   if (!argp2) {
91288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91289     return 0;
91290   }
91291   arg2 = *argp2;
91292   argp3 = (Dali::Actor *)jarg3;
91293   if (!argp3) {
91294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91295     return 0;
91296   }
91297   arg3 = *argp3;
91298   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
91299   {
91300     try {
91301       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
91302     } catch (std::out_of_range& e) {
91303       {
91304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91305       };
91306     } catch (std::exception& e) {
91307       {
91308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91309       };
91310     } catch (Dali::DaliException e) {
91311       {
91312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91313       };
91314     } catch (...) {
91315       {
91316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91317       };
91318     }
91319   }
91320
91321   jresult = new Dali::Actor((const Dali::Actor &)result);
91322   return jresult;
91323 }
91324
91325
91326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
91327   void * jresult ;
91328   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
91329
91330   {
91331     try {
91332       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
91333     } catch (std::out_of_range& e) {
91334       {
91335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91336       };
91337     } catch (std::exception& e) {
91338       {
91339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91340       };
91341     } catch (Dali::DaliException e) {
91342       {
91343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91344       };
91345     } catch (...) {
91346       {
91347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91348       };
91349     }
91350   }
91351
91352   jresult = (void *)result;
91353   return jresult;
91354 }
91355
91356
91357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
91358   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
91359   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
91360   if (director) {
91361     director->swig_connect_director(callback0);
91362   }
91363 }
91364
91365
91366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
91367   KeyboardFocusManager arg1 ;
91368   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
91369   KeyboardFocusManager *argp1 ;
91370
91371   argp1 = (KeyboardFocusManager *)jarg1;
91372   if (!argp1) {
91373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
91374     return ;
91375   }
91376   arg1 = *argp1;
91377   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
91378   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
91379   {
91380     try {
91381       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
91382     } catch (std::out_of_range& e) {
91383       {
91384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91385       };
91386     } catch (std::exception& e) {
91387       {
91388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91389       };
91390     } catch (Dali::DaliException e) {
91391       {
91392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91393       };
91394     } catch (...) {
91395       {
91396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91397       };
91398     }
91399   }
91400
91401 }
91402
91403
91404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
91405   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91406
91407   arg1 = (std::vector< unsigned int > *)jarg1;
91408   {
91409     try {
91410       (arg1)->clear();
91411     } catch (std::out_of_range& e) {
91412       {
91413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91414       };
91415     } catch (std::exception& e) {
91416       {
91417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91418       };
91419     } catch (Dali::DaliException e) {
91420       {
91421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91422       };
91423     } catch (...) {
91424       {
91425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91426       };
91427     }
91428   }
91429
91430 }
91431
91432
91433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
91434   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91435   unsigned int *arg2 = 0 ;
91436   unsigned int temp2 ;
91437
91438   arg1 = (std::vector< unsigned int > *)jarg1;
91439   temp2 = (unsigned int)jarg2;
91440   arg2 = &temp2;
91441   {
91442     try {
91443       (arg1)->push_back((unsigned int const &)*arg2);
91444     } catch (std::out_of_range& e) {
91445       {
91446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91447       };
91448     } catch (std::exception& e) {
91449       {
91450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91451       };
91452     } catch (Dali::DaliException e) {
91453       {
91454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91455       };
91456     } catch (...) {
91457       {
91458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91459       };
91460     }
91461   }
91462
91463 }
91464
91465
91466 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
91467   unsigned long jresult ;
91468   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91469   std::vector< unsigned int >::size_type result;
91470
91471   arg1 = (std::vector< unsigned int > *)jarg1;
91472   {
91473     try {
91474       result = ((std::vector< unsigned int > const *)arg1)->size();
91475     } catch (std::out_of_range& e) {
91476       {
91477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91478       };
91479     } catch (std::exception& e) {
91480       {
91481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91482       };
91483     } catch (Dali::DaliException e) {
91484       {
91485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91486       };
91487     } catch (...) {
91488       {
91489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91490       };
91491     }
91492   }
91493
91494   jresult = (unsigned long)result;
91495   return jresult;
91496 }
91497
91498
91499 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
91500   unsigned long jresult ;
91501   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91502   std::vector< unsigned int >::size_type result;
91503
91504   arg1 = (std::vector< unsigned int > *)jarg1;
91505   {
91506     try {
91507       result = ((std::vector< unsigned int > const *)arg1)->capacity();
91508     } catch (std::out_of_range& e) {
91509       {
91510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91511       };
91512     } catch (std::exception& e) {
91513       {
91514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91515       };
91516     } catch (Dali::DaliException e) {
91517       {
91518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91519       };
91520     } catch (...) {
91521       {
91522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91523       };
91524     }
91525   }
91526
91527   jresult = (unsigned long)result;
91528   return jresult;
91529 }
91530
91531
91532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
91533   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91534   std::vector< unsigned int >::size_type arg2 ;
91535
91536   arg1 = (std::vector< unsigned int > *)jarg1;
91537   arg2 = (std::vector< unsigned int >::size_type)jarg2;
91538   {
91539     try {
91540       (arg1)->reserve(arg2);
91541     } catch (std::out_of_range& e) {
91542       {
91543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91544       };
91545     } catch (std::exception& e) {
91546       {
91547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91548       };
91549     } catch (Dali::DaliException e) {
91550       {
91551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91552       };
91553     } catch (...) {
91554       {
91555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91556       };
91557     }
91558   }
91559
91560 }
91561
91562
91563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
91564   void * jresult ;
91565   std::vector< unsigned int > *result = 0 ;
91566
91567   {
91568     try {
91569       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
91570     } catch (std::out_of_range& e) {
91571       {
91572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91573       };
91574     } catch (std::exception& e) {
91575       {
91576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91577       };
91578     } catch (Dali::DaliException e) {
91579       {
91580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91581       };
91582     } catch (...) {
91583       {
91584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91585       };
91586     }
91587   }
91588
91589   jresult = (void *)result;
91590   return jresult;
91591 }
91592
91593
91594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
91595   void * jresult ;
91596   std::vector< unsigned int > *arg1 = 0 ;
91597   std::vector< unsigned int > *result = 0 ;
91598
91599   arg1 = (std::vector< unsigned int > *)jarg1;
91600   if (!arg1) {
91601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91602     return 0;
91603   }
91604   {
91605     try {
91606       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
91607     } catch (std::out_of_range& e) {
91608       {
91609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91610       };
91611     } catch (std::exception& e) {
91612       {
91613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91614       };
91615     } catch (Dali::DaliException e) {
91616       {
91617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91618       };
91619     } catch (...) {
91620       {
91621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91622       };
91623     }
91624   }
91625
91626   jresult = (void *)result;
91627   return jresult;
91628 }
91629
91630
91631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
91632   void * jresult ;
91633   int arg1 ;
91634   std::vector< unsigned int > *result = 0 ;
91635
91636   arg1 = (int)jarg1;
91637   {
91638     try {
91639       try {
91640         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
91641       }
91642       catch(std::out_of_range &_e) {
91643         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91644         return 0;
91645       }
91646
91647     } catch (std::out_of_range& e) {
91648       {
91649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91650       };
91651     } catch (std::exception& e) {
91652       {
91653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91654       };
91655     } catch (Dali::DaliException e) {
91656       {
91657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91658       };
91659     } catch (...) {
91660       {
91661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91662       };
91663     }
91664   }
91665
91666   jresult = (void *)result;
91667   return jresult;
91668 }
91669
91670
91671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
91672   unsigned int jresult ;
91673   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91674   int arg2 ;
91675   unsigned int result;
91676
91677   arg1 = (std::vector< unsigned int > *)jarg1;
91678   arg2 = (int)jarg2;
91679   {
91680     try {
91681       try {
91682         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
91683       }
91684       catch(std::out_of_range &_e) {
91685         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91686         return 0;
91687       }
91688
91689     } catch (std::out_of_range& e) {
91690       {
91691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91692       };
91693     } catch (std::exception& e) {
91694       {
91695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91696       };
91697     } catch (Dali::DaliException e) {
91698       {
91699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91700       };
91701     } catch (...) {
91702       {
91703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91704       };
91705     }
91706   }
91707
91708   jresult = result;
91709   return jresult;
91710 }
91711
91712
91713 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
91714   unsigned int jresult ;
91715   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91716   int arg2 ;
91717   unsigned int *result = 0 ;
91718
91719   arg1 = (std::vector< unsigned int > *)jarg1;
91720   arg2 = (int)jarg2;
91721   {
91722     try {
91723       try {
91724         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
91725       }
91726       catch(std::out_of_range &_e) {
91727         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91728         return 0;
91729       }
91730
91731     } catch (std::out_of_range& e) {
91732       {
91733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91734       };
91735     } catch (std::exception& e) {
91736       {
91737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91738       };
91739     } catch (Dali::DaliException e) {
91740       {
91741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91742       };
91743     } catch (...) {
91744       {
91745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91746       };
91747     }
91748   }
91749
91750   jresult = *result;
91751   return jresult;
91752 }
91753
91754
91755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
91756   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91757   int arg2 ;
91758   unsigned int *arg3 = 0 ;
91759   unsigned int temp3 ;
91760
91761   arg1 = (std::vector< unsigned int > *)jarg1;
91762   arg2 = (int)jarg2;
91763   temp3 = (unsigned int)jarg3;
91764   arg3 = &temp3;
91765   {
91766     try {
91767       try {
91768         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
91769       }
91770       catch(std::out_of_range &_e) {
91771         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91772         return ;
91773       }
91774
91775     } catch (std::out_of_range& e) {
91776       {
91777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91778       };
91779     } catch (std::exception& e) {
91780       {
91781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91782       };
91783     } catch (Dali::DaliException e) {
91784       {
91785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91786       };
91787     } catch (...) {
91788       {
91789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91790       };
91791     }
91792   }
91793
91794 }
91795
91796
91797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
91798   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91799   std::vector< unsigned int > *arg2 = 0 ;
91800
91801   arg1 = (std::vector< unsigned int > *)jarg1;
91802   arg2 = (std::vector< unsigned int > *)jarg2;
91803   if (!arg2) {
91804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91805     return ;
91806   }
91807   {
91808     try {
91809       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
91810     } catch (std::out_of_range& e) {
91811       {
91812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91813       };
91814     } catch (std::exception& e) {
91815       {
91816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91817       };
91818     } catch (Dali::DaliException e) {
91819       {
91820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91821       };
91822     } catch (...) {
91823       {
91824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91825       };
91826     }
91827   }
91828
91829 }
91830
91831
91832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
91833   void * jresult ;
91834   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91835   int arg2 ;
91836   int arg3 ;
91837   std::vector< unsigned int > *result = 0 ;
91838
91839   arg1 = (std::vector< unsigned int > *)jarg1;
91840   arg2 = (int)jarg2;
91841   arg3 = (int)jarg3;
91842   {
91843     try {
91844       try {
91845         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
91846       }
91847       catch(std::out_of_range &_e) {
91848         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91849         return 0;
91850       }
91851       catch(std::invalid_argument &_e) {
91852         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91853         return 0;
91854       }
91855
91856     } catch (std::out_of_range& e) {
91857       {
91858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91859       };
91860     } catch (std::exception& e) {
91861       {
91862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91863       };
91864     } catch (Dali::DaliException e) {
91865       {
91866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91867       };
91868     } catch (...) {
91869       {
91870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91871       };
91872     }
91873   }
91874
91875   jresult = (void *)result;
91876   return jresult;
91877 }
91878
91879
91880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
91881   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91882   int arg2 ;
91883   unsigned int *arg3 = 0 ;
91884   unsigned int temp3 ;
91885
91886   arg1 = (std::vector< unsigned int > *)jarg1;
91887   arg2 = (int)jarg2;
91888   temp3 = (unsigned int)jarg3;
91889   arg3 = &temp3;
91890   {
91891     try {
91892       try {
91893         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
91894       }
91895       catch(std::out_of_range &_e) {
91896         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91897         return ;
91898       }
91899
91900     } catch (std::out_of_range& e) {
91901       {
91902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91903       };
91904     } catch (std::exception& e) {
91905       {
91906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91907       };
91908     } catch (Dali::DaliException e) {
91909       {
91910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91911       };
91912     } catch (...) {
91913       {
91914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91915       };
91916     }
91917   }
91918
91919 }
91920
91921
91922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
91923   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91924   int arg2 ;
91925   std::vector< unsigned int > *arg3 = 0 ;
91926
91927   arg1 = (std::vector< unsigned int > *)jarg1;
91928   arg2 = (int)jarg2;
91929   arg3 = (std::vector< unsigned int > *)jarg3;
91930   if (!arg3) {
91931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91932     return ;
91933   }
91934   {
91935     try {
91936       try {
91937         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
91938       }
91939       catch(std::out_of_range &_e) {
91940         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91941         return ;
91942       }
91943
91944     } catch (std::out_of_range& e) {
91945       {
91946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91947       };
91948     } catch (std::exception& e) {
91949       {
91950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91951       };
91952     } catch (Dali::DaliException e) {
91953       {
91954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91955       };
91956     } catch (...) {
91957       {
91958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91959       };
91960     }
91961   }
91962
91963 }
91964
91965
91966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
91967   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91968   int arg2 ;
91969
91970   arg1 = (std::vector< unsigned int > *)jarg1;
91971   arg2 = (int)jarg2;
91972   {
91973     try {
91974       try {
91975         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
91976       }
91977       catch(std::out_of_range &_e) {
91978         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91979         return ;
91980       }
91981
91982     } catch (std::out_of_range& e) {
91983       {
91984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91985       };
91986     } catch (std::exception& e) {
91987       {
91988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91989       };
91990     } catch (Dali::DaliException e) {
91991       {
91992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91993       };
91994     } catch (...) {
91995       {
91996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91997       };
91998     }
91999   }
92000
92001 }
92002
92003
92004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
92005   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92006   int arg2 ;
92007   int arg3 ;
92008
92009   arg1 = (std::vector< unsigned int > *)jarg1;
92010   arg2 = (int)jarg2;
92011   arg3 = (int)jarg3;
92012   {
92013     try {
92014       try {
92015         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
92016       }
92017       catch(std::out_of_range &_e) {
92018         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92019         return ;
92020       }
92021       catch(std::invalid_argument &_e) {
92022         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92023         return ;
92024       }
92025
92026     } catch (std::out_of_range& e) {
92027       {
92028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92029       };
92030     } catch (std::exception& e) {
92031       {
92032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92033       };
92034     } catch (Dali::DaliException e) {
92035       {
92036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92037       };
92038     } catch (...) {
92039       {
92040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92041       };
92042     }
92043   }
92044
92045 }
92046
92047
92048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
92049   void * jresult ;
92050   unsigned int *arg1 = 0 ;
92051   int arg2 ;
92052   unsigned int temp1 ;
92053   std::vector< unsigned int > *result = 0 ;
92054
92055   temp1 = (unsigned int)jarg1;
92056   arg1 = &temp1;
92057   arg2 = (int)jarg2;
92058   {
92059     try {
92060       try {
92061         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
92062       }
92063       catch(std::out_of_range &_e) {
92064         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92065         return 0;
92066       }
92067
92068     } catch (std::out_of_range& e) {
92069       {
92070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92071       };
92072     } catch (std::exception& e) {
92073       {
92074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92075       };
92076     } catch (Dali::DaliException e) {
92077       {
92078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92079       };
92080     } catch (...) {
92081       {
92082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92083       };
92084     }
92085   }
92086
92087   jresult = (void *)result;
92088   return jresult;
92089 }
92090
92091
92092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
92093   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92094
92095   arg1 = (std::vector< unsigned int > *)jarg1;
92096   {
92097     try {
92098       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
92099     } catch (std::out_of_range& e) {
92100       {
92101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92102       };
92103     } catch (std::exception& e) {
92104       {
92105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92106       };
92107     } catch (Dali::DaliException e) {
92108       {
92109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92110       };
92111     } catch (...) {
92112       {
92113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92114       };
92115     }
92116   }
92117
92118 }
92119
92120
92121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
92122   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92123   int arg2 ;
92124   int arg3 ;
92125
92126   arg1 = (std::vector< unsigned int > *)jarg1;
92127   arg2 = (int)jarg2;
92128   arg3 = (int)jarg3;
92129   {
92130     try {
92131       try {
92132         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
92133       }
92134       catch(std::out_of_range &_e) {
92135         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92136         return ;
92137       }
92138       catch(std::invalid_argument &_e) {
92139         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92140         return ;
92141       }
92142
92143     } catch (std::out_of_range& e) {
92144       {
92145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92146       };
92147     } catch (std::exception& e) {
92148       {
92149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92150       };
92151     } catch (Dali::DaliException e) {
92152       {
92153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92154       };
92155     } catch (...) {
92156       {
92157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92158       };
92159     }
92160   }
92161
92162 }
92163
92164
92165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
92166   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92167   int arg2 ;
92168   std::vector< unsigned int > *arg3 = 0 ;
92169
92170   arg1 = (std::vector< unsigned int > *)jarg1;
92171   arg2 = (int)jarg2;
92172   arg3 = (std::vector< unsigned int > *)jarg3;
92173   if (!arg3) {
92174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92175     return ;
92176   }
92177   {
92178     try {
92179       try {
92180         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
92181       }
92182       catch(std::out_of_range &_e) {
92183         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92184         return ;
92185       }
92186
92187     } catch (std::out_of_range& e) {
92188       {
92189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92190       };
92191     } catch (std::exception& e) {
92192       {
92193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92194       };
92195     } catch (Dali::DaliException e) {
92196       {
92197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92198       };
92199     } catch (...) {
92200       {
92201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92202       };
92203     }
92204   }
92205
92206 }
92207
92208
92209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
92210   unsigned int jresult ;
92211   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92212   unsigned int *arg2 = 0 ;
92213   unsigned int temp2 ;
92214   bool result;
92215
92216   arg1 = (std::vector< unsigned int > *)jarg1;
92217   temp2 = (unsigned int)jarg2;
92218   arg2 = &temp2;
92219   {
92220     try {
92221       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
92222     } catch (std::out_of_range& e) {
92223       {
92224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92225       };
92226     } catch (std::exception& e) {
92227       {
92228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92229       };
92230     } catch (Dali::DaliException e) {
92231       {
92232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92233       };
92234     } catch (...) {
92235       {
92236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92237       };
92238     }
92239   }
92240
92241   jresult = result;
92242   return jresult;
92243 }
92244
92245
92246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
92247   int jresult ;
92248   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92249   unsigned int *arg2 = 0 ;
92250   unsigned int temp2 ;
92251   int result;
92252
92253   arg1 = (std::vector< unsigned int > *)jarg1;
92254   temp2 = (unsigned int)jarg2;
92255   arg2 = &temp2;
92256   {
92257     try {
92258       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
92259     } catch (std::out_of_range& e) {
92260       {
92261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92262       };
92263     } catch (std::exception& e) {
92264       {
92265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92266       };
92267     } catch (Dali::DaliException e) {
92268       {
92269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92270       };
92271     } catch (...) {
92272       {
92273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92274       };
92275     }
92276   }
92277
92278   jresult = result;
92279   return jresult;
92280 }
92281
92282
92283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
92284   int jresult ;
92285   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92286   unsigned int *arg2 = 0 ;
92287   unsigned int temp2 ;
92288   int result;
92289
92290   arg1 = (std::vector< unsigned int > *)jarg1;
92291   temp2 = (unsigned int)jarg2;
92292   arg2 = &temp2;
92293   {
92294     try {
92295       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
92296     } catch (std::out_of_range& e) {
92297       {
92298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92299       };
92300     } catch (std::exception& e) {
92301       {
92302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92303       };
92304     } catch (Dali::DaliException e) {
92305       {
92306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92307       };
92308     } catch (...) {
92309       {
92310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92311       };
92312     }
92313   }
92314
92315   jresult = result;
92316   return jresult;
92317 }
92318
92319
92320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
92321   unsigned int jresult ;
92322   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92323   unsigned int *arg2 = 0 ;
92324   unsigned int temp2 ;
92325   bool result;
92326
92327   arg1 = (std::vector< unsigned int > *)jarg1;
92328   temp2 = (unsigned int)jarg2;
92329   arg2 = &temp2;
92330   {
92331     try {
92332       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
92333     } catch (std::out_of_range& e) {
92334       {
92335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92336       };
92337     } catch (std::exception& e) {
92338       {
92339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92340       };
92341     } catch (Dali::DaliException e) {
92342       {
92343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92344       };
92345     } catch (...) {
92346       {
92347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92348       };
92349     }
92350   }
92351
92352   jresult = result;
92353   return jresult;
92354 }
92355
92356
92357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
92358   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92359
92360   arg1 = (std::vector< unsigned int > *)jarg1;
92361   {
92362     try {
92363       delete arg1;
92364     } catch (std::out_of_range& e) {
92365       {
92366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92367       };
92368     } catch (std::exception& e) {
92369       {
92370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92371       };
92372     } catch (Dali::DaliException e) {
92373       {
92374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92375       };
92376     } catch (...) {
92377       {
92378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92379       };
92380     }
92381   }
92382
92383 }
92384
92385
92386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
92387   void * jresult ;
92388   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92389
92390   {
92391     try {
92392       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
92393     } catch (std::out_of_range& e) {
92394       {
92395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92396       };
92397     } catch (std::exception& e) {
92398       {
92399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92400       };
92401     } catch (Dali::DaliException e) {
92402       {
92403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92404       };
92405     } catch (...) {
92406       {
92407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92408       };
92409     }
92410   }
92411
92412   jresult = (void *)result;
92413   return jresult;
92414 }
92415
92416
92417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
92418   void * jresult ;
92419   unsigned int arg1 ;
92420   Dali::Actor arg2 ;
92421   Dali::Actor *argp2 ;
92422   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92423
92424   arg1 = (unsigned int)jarg1;
92425   argp2 = (Dali::Actor *)jarg2;
92426   if (!argp2) {
92427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92428     return 0;
92429   }
92430   arg2 = *argp2;
92431   {
92432     try {
92433       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
92434     } catch (std::out_of_range& e) {
92435       {
92436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92437       };
92438     } catch (std::exception& e) {
92439       {
92440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92441       };
92442     } catch (Dali::DaliException e) {
92443       {
92444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92445       };
92446     } catch (...) {
92447       {
92448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92449       };
92450     }
92451   }
92452
92453   jresult = (void *)result;
92454   return jresult;
92455 }
92456
92457
92458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
92459   void * jresult ;
92460   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
92461   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92462
92463   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92464   if (!arg1) {
92465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92466     return 0;
92467   }
92468   {
92469     try {
92470       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
92471     } catch (std::out_of_range& e) {
92472       {
92473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92474       };
92475     } catch (std::exception& e) {
92476       {
92477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92478       };
92479     } catch (Dali::DaliException e) {
92480       {
92481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92482       };
92483     } catch (...) {
92484       {
92485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92486       };
92487     }
92488   }
92489
92490   jresult = (void *)result;
92491   return jresult;
92492 }
92493
92494
92495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
92496   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92497   unsigned int arg2 ;
92498
92499   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92500   arg2 = (unsigned int)jarg2;
92501   if (arg1) (arg1)->first = arg2;
92502 }
92503
92504
92505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
92506   unsigned int jresult ;
92507   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92508   unsigned int result;
92509
92510   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92511   result = (unsigned int) ((arg1)->first);
92512   jresult = result;
92513   return jresult;
92514 }
92515
92516
92517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
92518   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92519   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
92520
92521   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92522   arg2 = (Dali::Actor *)jarg2;
92523   if (arg1) (arg1)->second = *arg2;
92524 }
92525
92526
92527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
92528   void * jresult ;
92529   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92530   Dali::Actor *result = 0 ;
92531
92532   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92533   result = (Dali::Actor *)& ((arg1)->second);
92534   jresult = (void *)result;
92535   return jresult;
92536 }
92537
92538
92539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
92540   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92541
92542   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92543   {
92544     try {
92545       delete arg1;
92546     } catch (std::out_of_range& e) {
92547       {
92548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92549       };
92550     } catch (std::exception& e) {
92551       {
92552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92553       };
92554     } catch (Dali::DaliException e) {
92555       {
92556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92557       };
92558     } catch (...) {
92559       {
92560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92561       };
92562     }
92563   }
92564
92565 }
92566
92567
92568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
92569   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92570
92571   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92572   {
92573     try {
92574       (arg1)->clear();
92575     } catch (std::out_of_range& e) {
92576       {
92577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92578       };
92579     } catch (std::exception& e) {
92580       {
92581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92582       };
92583     } catch (Dali::DaliException e) {
92584       {
92585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92586       };
92587     } catch (...) {
92588       {
92589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92590       };
92591     }
92592   }
92593
92594 }
92595
92596
92597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
92598   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92599   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
92600
92601   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92602   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
92603   if (!arg2) {
92604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92605     return ;
92606   }
92607   {
92608     try {
92609       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
92610     } catch (std::out_of_range& e) {
92611       {
92612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92613       };
92614     } catch (std::exception& e) {
92615       {
92616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92617       };
92618     } catch (Dali::DaliException e) {
92619       {
92620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92621       };
92622     } catch (...) {
92623       {
92624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92625       };
92626     }
92627   }
92628
92629 }
92630
92631
92632 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
92633   unsigned long jresult ;
92634   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92635   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
92636
92637   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92638   {
92639     try {
92640       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
92641     } catch (std::out_of_range& e) {
92642       {
92643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92644       };
92645     } catch (std::exception& e) {
92646       {
92647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92648       };
92649     } catch (Dali::DaliException e) {
92650       {
92651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92652       };
92653     } catch (...) {
92654       {
92655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92656       };
92657     }
92658   }
92659
92660   jresult = (unsigned long)result;
92661   return jresult;
92662 }
92663
92664
92665 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
92666   unsigned long jresult ;
92667   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92668   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
92669
92670   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92671   {
92672     try {
92673       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
92674     } catch (std::out_of_range& e) {
92675       {
92676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92677       };
92678     } catch (std::exception& e) {
92679       {
92680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92681       };
92682     } catch (Dali::DaliException e) {
92683       {
92684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92685       };
92686     } catch (...) {
92687       {
92688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92689       };
92690     }
92691   }
92692
92693   jresult = (unsigned long)result;
92694   return jresult;
92695 }
92696
92697
92698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
92699   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92700   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
92701
92702   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92703   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
92704   {
92705     try {
92706       (arg1)->reserve(arg2);
92707     } catch (std::out_of_range& e) {
92708       {
92709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92710       };
92711     } catch (std::exception& e) {
92712       {
92713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92714       };
92715     } catch (Dali::DaliException e) {
92716       {
92717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92718       };
92719     } catch (...) {
92720       {
92721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92722       };
92723     }
92724   }
92725
92726 }
92727
92728
92729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
92730   void * jresult ;
92731   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92732
92733   {
92734     try {
92735       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
92736     } catch (std::out_of_range& e) {
92737       {
92738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92739       };
92740     } catch (std::exception& e) {
92741       {
92742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92743       };
92744     } catch (Dali::DaliException e) {
92745       {
92746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92747       };
92748     } catch (...) {
92749       {
92750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92751       };
92752     }
92753   }
92754
92755   jresult = (void *)result;
92756   return jresult;
92757 }
92758
92759
92760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
92761   void * jresult ;
92762   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
92763   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92764
92765   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92766   if (!arg1) {
92767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
92768     return 0;
92769   }
92770   {
92771     try {
92772       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);
92773     } catch (std::out_of_range& e) {
92774       {
92775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92776       };
92777     } catch (std::exception& e) {
92778       {
92779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92780       };
92781     } catch (Dali::DaliException e) {
92782       {
92783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92784       };
92785     } catch (...) {
92786       {
92787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92788       };
92789     }
92790   }
92791
92792   jresult = (void *)result;
92793   return jresult;
92794 }
92795
92796
92797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
92798   void * jresult ;
92799   int arg1 ;
92800   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92801
92802   arg1 = (int)jarg1;
92803   {
92804     try {
92805       try {
92806         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);
92807       }
92808       catch(std::out_of_range &_e) {
92809         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92810         return 0;
92811       }
92812
92813     } catch (std::out_of_range& e) {
92814       {
92815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92816       };
92817     } catch (std::exception& e) {
92818       {
92819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92820       };
92821     } catch (Dali::DaliException e) {
92822       {
92823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92824       };
92825     } catch (...) {
92826       {
92827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92828       };
92829     }
92830   }
92831
92832   jresult = (void *)result;
92833   return jresult;
92834 }
92835
92836
92837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
92838   void * jresult ;
92839   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92840   int arg2 ;
92841   std::pair< unsigned int,Dali::Actor > result;
92842
92843   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92844   arg2 = (int)jarg2;
92845   {
92846     try {
92847       try {
92848         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
92849       }
92850       catch(std::out_of_range &_e) {
92851         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92852         return 0;
92853       }
92854
92855     } catch (std::out_of_range& e) {
92856       {
92857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92858       };
92859     } catch (std::exception& e) {
92860       {
92861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92862       };
92863     } catch (Dali::DaliException e) {
92864       {
92865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92866       };
92867     } catch (...) {
92868       {
92869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92870       };
92871     }
92872   }
92873
92874   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
92875   return jresult;
92876 }
92877
92878
92879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
92880   void * jresult ;
92881   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92882   int arg2 ;
92883   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92884
92885   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92886   arg2 = (int)jarg2;
92887   {
92888     try {
92889       try {
92890         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
92891       }
92892       catch(std::out_of_range &_e) {
92893         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92894         return 0;
92895       }
92896
92897     } catch (std::out_of_range& e) {
92898       {
92899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92900       };
92901     } catch (std::exception& e) {
92902       {
92903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92904       };
92905     } catch (Dali::DaliException e) {
92906       {
92907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92908       };
92909     } catch (...) {
92910       {
92911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92912       };
92913     }
92914   }
92915
92916   jresult = (void *)result;
92917   return jresult;
92918 }
92919
92920
92921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
92922   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92923   int arg2 ;
92924   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
92925
92926   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92927   arg2 = (int)jarg2;
92928   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
92929   if (!arg3) {
92930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92931     return ;
92932   }
92933   {
92934     try {
92935       try {
92936         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);
92937       }
92938       catch(std::out_of_range &_e) {
92939         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92940         return ;
92941       }
92942
92943     } catch (std::out_of_range& e) {
92944       {
92945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92946       };
92947     } catch (std::exception& e) {
92948       {
92949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92950       };
92951     } catch (Dali::DaliException e) {
92952       {
92953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92954       };
92955     } catch (...) {
92956       {
92957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92958       };
92959     }
92960   }
92961
92962 }
92963
92964
92965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
92966   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92967   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
92968
92969   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92970   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
92971   if (!arg2) {
92972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
92973     return ;
92974   }
92975   {
92976     try {
92977       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);
92978     } catch (std::out_of_range& e) {
92979       {
92980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92981       };
92982     } catch (std::exception& e) {
92983       {
92984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92985       };
92986     } catch (Dali::DaliException e) {
92987       {
92988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92989       };
92990     } catch (...) {
92991       {
92992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92993       };
92994     }
92995   }
92996
92997 }
92998
92999
93000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93001   void * jresult ;
93002   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93003   int arg2 ;
93004   int arg3 ;
93005   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93006
93007   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93008   arg2 = (int)jarg2;
93009   arg3 = (int)jarg3;
93010   {
93011     try {
93012       try {
93013         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);
93014       }
93015       catch(std::out_of_range &_e) {
93016         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93017         return 0;
93018       }
93019       catch(std::invalid_argument &_e) {
93020         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93021         return 0;
93022       }
93023
93024     } catch (std::out_of_range& e) {
93025       {
93026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93027       };
93028     } catch (std::exception& e) {
93029       {
93030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93031       };
93032     } catch (Dali::DaliException e) {
93033       {
93034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93035       };
93036     } catch (...) {
93037       {
93038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93039       };
93040     }
93041   }
93042
93043   jresult = (void *)result;
93044   return jresult;
93045 }
93046
93047
93048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
93049   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93050   int arg2 ;
93051   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
93052
93053   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93054   arg2 = (int)jarg2;
93055   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
93056   if (!arg3) {
93057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93058     return ;
93059   }
93060   {
93061     try {
93062       try {
93063         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);
93064       }
93065       catch(std::out_of_range &_e) {
93066         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93067         return ;
93068       }
93069
93070     } catch (std::out_of_range& e) {
93071       {
93072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93073       };
93074     } catch (std::exception& e) {
93075       {
93076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93077       };
93078     } catch (Dali::DaliException e) {
93079       {
93080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93081       };
93082     } catch (...) {
93083       {
93084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93085       };
93086     }
93087   }
93088
93089 }
93090
93091
93092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93093   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93094   int arg2 ;
93095   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
93096
93097   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93098   arg2 = (int)jarg2;
93099   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
93100   if (!arg3) {
93101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93102     return ;
93103   }
93104   {
93105     try {
93106       try {
93107         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);
93108       }
93109       catch(std::out_of_range &_e) {
93110         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93111         return ;
93112       }
93113
93114     } catch (std::out_of_range& e) {
93115       {
93116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93117       };
93118     } catch (std::exception& e) {
93119       {
93120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93121       };
93122     } catch (Dali::DaliException e) {
93123       {
93124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93125       };
93126     } catch (...) {
93127       {
93128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93129       };
93130     }
93131   }
93132
93133 }
93134
93135
93136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
93137   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93138   int arg2 ;
93139
93140   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93141   arg2 = (int)jarg2;
93142   {
93143     try {
93144       try {
93145         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
93146       }
93147       catch(std::out_of_range &_e) {
93148         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93149         return ;
93150       }
93151
93152     } catch (std::out_of_range& e) {
93153       {
93154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93155       };
93156     } catch (std::exception& e) {
93157       {
93158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93159       };
93160     } catch (Dali::DaliException e) {
93161       {
93162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93163       };
93164     } catch (...) {
93165       {
93166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93167       };
93168     }
93169   }
93170
93171 }
93172
93173
93174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93175   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93176   int arg2 ;
93177   int arg3 ;
93178
93179   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93180   arg2 = (int)jarg2;
93181   arg3 = (int)jarg3;
93182   {
93183     try {
93184       try {
93185         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
93186       }
93187       catch(std::out_of_range &_e) {
93188         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93189         return ;
93190       }
93191       catch(std::invalid_argument &_e) {
93192         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93193         return ;
93194       }
93195
93196     } catch (std::out_of_range& e) {
93197       {
93198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93199       };
93200     } catch (std::exception& e) {
93201       {
93202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93203       };
93204     } catch (Dali::DaliException e) {
93205       {
93206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93207       };
93208     } catch (...) {
93209       {
93210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93211       };
93212     }
93213   }
93214
93215 }
93216
93217
93218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
93219   void * jresult ;
93220   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93221   int arg2 ;
93222   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93223
93224   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93225   if (!arg1) {
93226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93227     return 0;
93228   }
93229   arg2 = (int)jarg2;
93230   {
93231     try {
93232       try {
93233         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);
93234       }
93235       catch(std::out_of_range &_e) {
93236         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93237         return 0;
93238       }
93239
93240     } catch (std::out_of_range& e) {
93241       {
93242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93243       };
93244     } catch (std::exception& e) {
93245       {
93246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93247       };
93248     } catch (Dali::DaliException e) {
93249       {
93250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93251       };
93252     } catch (...) {
93253       {
93254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93255       };
93256     }
93257   }
93258
93259   jresult = (void *)result;
93260   return jresult;
93261 }
93262
93263
93264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
93265   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93266
93267   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93268   {
93269     try {
93270       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
93271     } catch (std::out_of_range& e) {
93272       {
93273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93274       };
93275     } catch (std::exception& e) {
93276       {
93277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93278       };
93279     } catch (Dali::DaliException e) {
93280       {
93281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93282       };
93283     } catch (...) {
93284       {
93285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93286       };
93287     }
93288   }
93289
93290 }
93291
93292
93293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93294   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93295   int arg2 ;
93296   int arg3 ;
93297
93298   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93299   arg2 = (int)jarg2;
93300   arg3 = (int)jarg3;
93301   {
93302     try {
93303       try {
93304         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93305       }
93306       catch(std::out_of_range &_e) {
93307         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93308         return ;
93309       }
93310       catch(std::invalid_argument &_e) {
93311         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93312         return ;
93313       }
93314
93315     } catch (std::out_of_range& e) {
93316       {
93317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93318       };
93319     } catch (std::exception& e) {
93320       {
93321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93322       };
93323     } catch (Dali::DaliException e) {
93324       {
93325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93326       };
93327     } catch (...) {
93328       {
93329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93330       };
93331     }
93332   }
93333
93334 }
93335
93336
93337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93338   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93339   int arg2 ;
93340   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
93341
93342   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93343   arg2 = (int)jarg2;
93344   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
93345   if (!arg3) {
93346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93347     return ;
93348   }
93349   {
93350     try {
93351       try {
93352         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);
93353       }
93354       catch(std::out_of_range &_e) {
93355         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93356         return ;
93357       }
93358
93359     } catch (std::out_of_range& e) {
93360       {
93361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93362       };
93363     } catch (std::exception& e) {
93364       {
93365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93366       };
93367     } catch (Dali::DaliException e) {
93368       {
93369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93370       };
93371     } catch (...) {
93372       {
93373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93374       };
93375     }
93376   }
93377
93378 }
93379
93380
93381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
93382   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93383
93384   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93385   {
93386     try {
93387       delete arg1;
93388     } catch (std::out_of_range& e) {
93389       {
93390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93391       };
93392     } catch (std::exception& e) {
93393       {
93394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93395       };
93396     } catch (Dali::DaliException e) {
93397       {
93398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93399       };
93400     } catch (...) {
93401       {
93402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93403       };
93404     }
93405   }
93406
93407 }
93408
93409
93410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
93411   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93412
93413   arg1 = (std::vector< Dali::Actor > *)jarg1;
93414   {
93415     try {
93416       (arg1)->clear();
93417     } catch (std::out_of_range& e) {
93418       {
93419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93420       };
93421     } catch (std::exception& e) {
93422       {
93423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93424       };
93425     } catch (Dali::DaliException e) {
93426       {
93427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93428       };
93429     } catch (...) {
93430       {
93431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93432       };
93433     }
93434   }
93435
93436 }
93437
93438
93439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
93440   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93441   Dali::Actor *arg2 = 0 ;
93442
93443   arg1 = (std::vector< Dali::Actor > *)jarg1;
93444   arg2 = (Dali::Actor *)jarg2;
93445   if (!arg2) {
93446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93447     return ;
93448   }
93449   {
93450     try {
93451       (arg1)->push_back((Dali::Actor const &)*arg2);
93452     } catch (std::out_of_range& e) {
93453       {
93454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93455       };
93456     } catch (std::exception& e) {
93457       {
93458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93459       };
93460     } catch (Dali::DaliException e) {
93461       {
93462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93463       };
93464     } catch (...) {
93465       {
93466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93467       };
93468     }
93469   }
93470
93471 }
93472
93473
93474 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
93475   unsigned long jresult ;
93476   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93477   std::vector< Dali::Actor >::size_type result;
93478
93479   arg1 = (std::vector< Dali::Actor > *)jarg1;
93480   {
93481     try {
93482       result = ((std::vector< Dali::Actor > const *)arg1)->size();
93483     } catch (std::out_of_range& e) {
93484       {
93485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93486       };
93487     } catch (std::exception& e) {
93488       {
93489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93490       };
93491     } catch (Dali::DaliException e) {
93492       {
93493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93494       };
93495     } catch (...) {
93496       {
93497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93498       };
93499     }
93500   }
93501
93502   jresult = (unsigned long)result;
93503   return jresult;
93504 }
93505
93506
93507 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
93508   unsigned long jresult ;
93509   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93510   std::vector< Dali::Actor >::size_type result;
93511
93512   arg1 = (std::vector< Dali::Actor > *)jarg1;
93513   {
93514     try {
93515       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
93516     } catch (std::out_of_range& e) {
93517       {
93518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93519       };
93520     } catch (std::exception& e) {
93521       {
93522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93523       };
93524     } catch (Dali::DaliException e) {
93525       {
93526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93527       };
93528     } catch (...) {
93529       {
93530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93531       };
93532     }
93533   }
93534
93535   jresult = (unsigned long)result;
93536   return jresult;
93537 }
93538
93539
93540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
93541   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93542   std::vector< Dali::Actor >::size_type arg2 ;
93543
93544   arg1 = (std::vector< Dali::Actor > *)jarg1;
93545   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
93546   {
93547     try {
93548       (arg1)->reserve(arg2);
93549     } catch (std::out_of_range& e) {
93550       {
93551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93552       };
93553     } catch (std::exception& e) {
93554       {
93555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93556       };
93557     } catch (Dali::DaliException e) {
93558       {
93559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93560       };
93561     } catch (...) {
93562       {
93563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93564       };
93565     }
93566   }
93567
93568 }
93569
93570
93571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
93572   void * jresult ;
93573   std::vector< Dali::Actor > *result = 0 ;
93574
93575   {
93576     try {
93577       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
93578     } catch (std::out_of_range& e) {
93579       {
93580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93581       };
93582     } catch (std::exception& e) {
93583       {
93584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93585       };
93586     } catch (Dali::DaliException e) {
93587       {
93588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93589       };
93590     } catch (...) {
93591       {
93592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93593       };
93594     }
93595   }
93596
93597   jresult = (void *)result;
93598   return jresult;
93599 }
93600
93601
93602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
93603   void * jresult ;
93604   std::vector< Dali::Actor > *arg1 = 0 ;
93605   std::vector< Dali::Actor > *result = 0 ;
93606
93607   arg1 = (std::vector< Dali::Actor > *)jarg1;
93608   if (!arg1) {
93609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93610     return 0;
93611   }
93612   {
93613     try {
93614       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
93615     } catch (std::out_of_range& e) {
93616       {
93617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93618       };
93619     } catch (std::exception& e) {
93620       {
93621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93622       };
93623     } catch (Dali::DaliException e) {
93624       {
93625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93626       };
93627     } catch (...) {
93628       {
93629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93630       };
93631     }
93632   }
93633
93634   jresult = (void *)result;
93635   return jresult;
93636 }
93637
93638
93639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
93640   void * jresult ;
93641   int arg1 ;
93642   std::vector< Dali::Actor > *result = 0 ;
93643
93644   arg1 = (int)jarg1;
93645   {
93646     try {
93647       try {
93648         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
93649       }
93650       catch(std::out_of_range &_e) {
93651         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93652         return 0;
93653       }
93654
93655     } catch (std::out_of_range& e) {
93656       {
93657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93658       };
93659     } catch (std::exception& e) {
93660       {
93661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93662       };
93663     } catch (Dali::DaliException e) {
93664       {
93665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93666       };
93667     } catch (...) {
93668       {
93669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93670       };
93671     }
93672   }
93673
93674   jresult = (void *)result;
93675   return jresult;
93676 }
93677
93678
93679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
93680   void * jresult ;
93681   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93682   int arg2 ;
93683   Dali::Actor result;
93684
93685   arg1 = (std::vector< Dali::Actor > *)jarg1;
93686   arg2 = (int)jarg2;
93687   {
93688     try {
93689       try {
93690         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
93691       }
93692       catch(std::out_of_range &_e) {
93693         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93694         return 0;
93695       }
93696
93697     } catch (std::out_of_range& e) {
93698       {
93699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93700       };
93701     } catch (std::exception& e) {
93702       {
93703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93704       };
93705     } catch (Dali::DaliException e) {
93706       {
93707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93708       };
93709     } catch (...) {
93710       {
93711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93712       };
93713     }
93714   }
93715
93716   jresult = new Dali::Actor((const Dali::Actor &)result);
93717   return jresult;
93718 }
93719
93720
93721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
93722   void * jresult ;
93723   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93724   int arg2 ;
93725   Dali::Actor *result = 0 ;
93726
93727   arg1 = (std::vector< Dali::Actor > *)jarg1;
93728   arg2 = (int)jarg2;
93729   {
93730     try {
93731       try {
93732         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
93733       }
93734       catch(std::out_of_range &_e) {
93735         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93736         return 0;
93737       }
93738
93739     } catch (std::out_of_range& e) {
93740       {
93741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93742       };
93743     } catch (std::exception& e) {
93744       {
93745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93746       };
93747     } catch (Dali::DaliException e) {
93748       {
93749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93750       };
93751     } catch (...) {
93752       {
93753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93754       };
93755     }
93756   }
93757
93758   jresult = (void *)result;
93759   return jresult;
93760 }
93761
93762
93763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
93764   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93765   int arg2 ;
93766   Dali::Actor *arg3 = 0 ;
93767
93768   arg1 = (std::vector< Dali::Actor > *)jarg1;
93769   arg2 = (int)jarg2;
93770   arg3 = (Dali::Actor *)jarg3;
93771   if (!arg3) {
93772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93773     return ;
93774   }
93775   {
93776     try {
93777       try {
93778         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
93779       }
93780       catch(std::out_of_range &_e) {
93781         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93782         return ;
93783       }
93784
93785     } catch (std::out_of_range& e) {
93786       {
93787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93788       };
93789     } catch (std::exception& e) {
93790       {
93791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93792       };
93793     } catch (Dali::DaliException e) {
93794       {
93795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93796       };
93797     } catch (...) {
93798       {
93799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93800       };
93801     }
93802   }
93803
93804 }
93805
93806
93807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
93808   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93809   std::vector< Dali::Actor > *arg2 = 0 ;
93810
93811   arg1 = (std::vector< Dali::Actor > *)jarg1;
93812   arg2 = (std::vector< Dali::Actor > *)jarg2;
93813   if (!arg2) {
93814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93815     return ;
93816   }
93817   {
93818     try {
93819       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
93820     } catch (std::out_of_range& e) {
93821       {
93822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93823       };
93824     } catch (std::exception& e) {
93825       {
93826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93827       };
93828     } catch (Dali::DaliException e) {
93829       {
93830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93831       };
93832     } catch (...) {
93833       {
93834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93835       };
93836     }
93837   }
93838
93839 }
93840
93841
93842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93843   void * jresult ;
93844   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93845   int arg2 ;
93846   int arg3 ;
93847   std::vector< Dali::Actor > *result = 0 ;
93848
93849   arg1 = (std::vector< Dali::Actor > *)jarg1;
93850   arg2 = (int)jarg2;
93851   arg3 = (int)jarg3;
93852   {
93853     try {
93854       try {
93855         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
93856       }
93857       catch(std::out_of_range &_e) {
93858         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93859         return 0;
93860       }
93861       catch(std::invalid_argument &_e) {
93862         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93863         return 0;
93864       }
93865
93866     } catch (std::out_of_range& e) {
93867       {
93868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93869       };
93870     } catch (std::exception& e) {
93871       {
93872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93873       };
93874     } catch (Dali::DaliException e) {
93875       {
93876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93877       };
93878     } catch (...) {
93879       {
93880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93881       };
93882     }
93883   }
93884
93885   jresult = (void *)result;
93886   return jresult;
93887 }
93888
93889
93890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
93891   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93892   int arg2 ;
93893   Dali::Actor *arg3 = 0 ;
93894
93895   arg1 = (std::vector< Dali::Actor > *)jarg1;
93896   arg2 = (int)jarg2;
93897   arg3 = (Dali::Actor *)jarg3;
93898   if (!arg3) {
93899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93900     return ;
93901   }
93902   {
93903     try {
93904       try {
93905         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
93906       }
93907       catch(std::out_of_range &_e) {
93908         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93909         return ;
93910       }
93911
93912     } catch (std::out_of_range& e) {
93913       {
93914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93915       };
93916     } catch (std::exception& e) {
93917       {
93918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93919       };
93920     } catch (Dali::DaliException e) {
93921       {
93922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93923       };
93924     } catch (...) {
93925       {
93926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93927       };
93928     }
93929   }
93930
93931 }
93932
93933
93934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93935   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93936   int arg2 ;
93937   std::vector< Dali::Actor > *arg3 = 0 ;
93938
93939   arg1 = (std::vector< Dali::Actor > *)jarg1;
93940   arg2 = (int)jarg2;
93941   arg3 = (std::vector< Dali::Actor > *)jarg3;
93942   if (!arg3) {
93943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93944     return ;
93945   }
93946   {
93947     try {
93948       try {
93949         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
93950       }
93951       catch(std::out_of_range &_e) {
93952         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93953         return ;
93954       }
93955
93956     } catch (std::out_of_range& e) {
93957       {
93958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93959       };
93960     } catch (std::exception& e) {
93961       {
93962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93963       };
93964     } catch (Dali::DaliException e) {
93965       {
93966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93967       };
93968     } catch (...) {
93969       {
93970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93971       };
93972     }
93973   }
93974
93975 }
93976
93977
93978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
93979   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93980   int arg2 ;
93981
93982   arg1 = (std::vector< Dali::Actor > *)jarg1;
93983   arg2 = (int)jarg2;
93984   {
93985     try {
93986       try {
93987         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
93988       }
93989       catch(std::out_of_range &_e) {
93990         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93991         return ;
93992       }
93993
93994     } catch (std::out_of_range& e) {
93995       {
93996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93997       };
93998     } catch (std::exception& e) {
93999       {
94000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94001       };
94002     } catch (Dali::DaliException e) {
94003       {
94004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94005       };
94006     } catch (...) {
94007       {
94008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94009       };
94010     }
94011   }
94012
94013 }
94014
94015
94016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94017   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94018   int arg2 ;
94019   int arg3 ;
94020
94021   arg1 = (std::vector< Dali::Actor > *)jarg1;
94022   arg2 = (int)jarg2;
94023   arg3 = (int)jarg3;
94024   {
94025     try {
94026       try {
94027         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
94028       }
94029       catch(std::out_of_range &_e) {
94030         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94031         return ;
94032       }
94033       catch(std::invalid_argument &_e) {
94034         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94035         return ;
94036       }
94037
94038     } catch (std::out_of_range& e) {
94039       {
94040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94041       };
94042     } catch (std::exception& e) {
94043       {
94044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94045       };
94046     } catch (Dali::DaliException e) {
94047       {
94048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94049       };
94050     } catch (...) {
94051       {
94052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94053       };
94054     }
94055   }
94056
94057 }
94058
94059
94060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
94061   void * jresult ;
94062   Dali::Actor *arg1 = 0 ;
94063   int arg2 ;
94064   std::vector< Dali::Actor > *result = 0 ;
94065
94066   arg1 = (Dali::Actor *)jarg1;
94067   if (!arg1) {
94068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94069     return 0;
94070   }
94071   arg2 = (int)jarg2;
94072   {
94073     try {
94074       try {
94075         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
94076       }
94077       catch(std::out_of_range &_e) {
94078         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94079         return 0;
94080       }
94081
94082     } catch (std::out_of_range& e) {
94083       {
94084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94085       };
94086     } catch (std::exception& e) {
94087       {
94088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94089       };
94090     } catch (Dali::DaliException e) {
94091       {
94092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94093       };
94094     } catch (...) {
94095       {
94096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94097       };
94098     }
94099   }
94100
94101   jresult = (void *)result;
94102   return jresult;
94103 }
94104
94105
94106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
94107   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94108
94109   arg1 = (std::vector< Dali::Actor > *)jarg1;
94110   {
94111     try {
94112       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
94113     } catch (std::out_of_range& e) {
94114       {
94115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94116       };
94117     } catch (std::exception& e) {
94118       {
94119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94120       };
94121     } catch (Dali::DaliException e) {
94122       {
94123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94124       };
94125     } catch (...) {
94126       {
94127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94128       };
94129     }
94130   }
94131
94132 }
94133
94134
94135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94136   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94137   int arg2 ;
94138   int arg3 ;
94139
94140   arg1 = (std::vector< Dali::Actor > *)jarg1;
94141   arg2 = (int)jarg2;
94142   arg3 = (int)jarg3;
94143   {
94144     try {
94145       try {
94146         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94147       }
94148       catch(std::out_of_range &_e) {
94149         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94150         return ;
94151       }
94152       catch(std::invalid_argument &_e) {
94153         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94154         return ;
94155       }
94156
94157     } catch (std::out_of_range& e) {
94158       {
94159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94160       };
94161     } catch (std::exception& e) {
94162       {
94163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94164       };
94165     } catch (Dali::DaliException e) {
94166       {
94167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94168       };
94169     } catch (...) {
94170       {
94171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94172       };
94173     }
94174   }
94175
94176 }
94177
94178
94179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94180   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94181   int arg2 ;
94182   std::vector< Dali::Actor > *arg3 = 0 ;
94183
94184   arg1 = (std::vector< Dali::Actor > *)jarg1;
94185   arg2 = (int)jarg2;
94186   arg3 = (std::vector< Dali::Actor > *)jarg3;
94187   if (!arg3) {
94188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94189     return ;
94190   }
94191   {
94192     try {
94193       try {
94194         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
94195       }
94196       catch(std::out_of_range &_e) {
94197         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94198         return ;
94199       }
94200
94201     } catch (std::out_of_range& e) {
94202       {
94203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94204       };
94205     } catch (std::exception& e) {
94206       {
94207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94208       };
94209     } catch (Dali::DaliException e) {
94210       {
94211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94212       };
94213     } catch (...) {
94214       {
94215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94216       };
94217     }
94218   }
94219
94220 }
94221
94222
94223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
94224   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94225
94226   arg1 = (std::vector< Dali::Actor > *)jarg1;
94227   {
94228     try {
94229       delete arg1;
94230     } catch (std::out_of_range& e) {
94231       {
94232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94233       };
94234     } catch (std::exception& e) {
94235       {
94236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94237       };
94238     } catch (Dali::DaliException e) {
94239       {
94240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94241       };
94242     } catch (...) {
94243       {
94244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94245       };
94246     }
94247   }
94248
94249 }
94250
94251
94252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
94253   unsigned int jresult ;
94254   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94255   bool result;
94256
94257   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94258   {
94259     try {
94260       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
94261     } catch (std::out_of_range& e) {
94262       {
94263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94264       };
94265     } catch (std::exception& e) {
94266       {
94267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94268       };
94269     } catch (Dali::DaliException e) {
94270       {
94271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94272       };
94273     } catch (...) {
94274       {
94275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94276       };
94277     }
94278   }
94279
94280   jresult = result;
94281   return jresult;
94282 }
94283
94284
94285 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
94286   unsigned long jresult ;
94287   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94288   std::size_t result;
94289
94290   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94291   {
94292     try {
94293       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
94294     } catch (std::out_of_range& e) {
94295       {
94296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94297       };
94298     } catch (std::exception& e) {
94299       {
94300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94301       };
94302     } catch (Dali::DaliException e) {
94303       {
94304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94305       };
94306     } catch (...) {
94307       {
94308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94309       };
94310     }
94311   }
94312
94313   jresult = (unsigned long)result;
94314   return jresult;
94315 }
94316
94317
94318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
94319   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94320   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
94321
94322   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94323   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
94324   {
94325     try {
94326       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
94327     } catch (std::out_of_range& e) {
94328       {
94329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94330       };
94331     } catch (std::exception& e) {
94332       {
94333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94334       };
94335     } catch (Dali::DaliException e) {
94336       {
94337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94338       };
94339     } catch (...) {
94340       {
94341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94342       };
94343     }
94344   }
94345
94346 }
94347
94348
94349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
94350   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94351   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
94352
94353   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94354   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
94355   {
94356     try {
94357       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
94358     } catch (std::out_of_range& e) {
94359       {
94360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94361       };
94362     } catch (std::exception& e) {
94363       {
94364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94365       };
94366     } catch (Dali::DaliException e) {
94367       {
94368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94369       };
94370     } catch (...) {
94371       {
94372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94373       };
94374     }
94375   }
94376
94377 }
94378
94379
94380 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
94381   unsigned int jresult ;
94382   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94383   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
94384   bool result;
94385
94386   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94387   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
94388   if (!arg2) {
94389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
94390     return 0;
94391   }
94392   {
94393     try {
94394       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
94395     } catch (std::out_of_range& e) {
94396       {
94397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94398       };
94399     } catch (std::exception& e) {
94400       {
94401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94402       };
94403     } catch (Dali::DaliException e) {
94404       {
94405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94406       };
94407     } catch (...) {
94408       {
94409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94410       };
94411     }
94412   }
94413
94414   jresult = result;
94415   return jresult;
94416 }
94417
94418
94419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
94420   void * jresult ;
94421   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
94422
94423   {
94424     try {
94425       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
94426     } catch (std::out_of_range& e) {
94427       {
94428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94429       };
94430     } catch (std::exception& e) {
94431       {
94432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94433       };
94434     } catch (Dali::DaliException e) {
94435       {
94436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94437       };
94438     } catch (...) {
94439       {
94440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94441       };
94442     }
94443   }
94444
94445   jresult = (void *)result;
94446   return jresult;
94447 }
94448
94449
94450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
94451   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94452
94453   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94454   {
94455     try {
94456       delete arg1;
94457     } catch (std::out_of_range& e) {
94458       {
94459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94460       };
94461     } catch (std::exception& e) {
94462       {
94463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94464       };
94465     } catch (Dali::DaliException e) {
94466       {
94467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94468       };
94469     } catch (...) {
94470       {
94471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94472       };
94473     }
94474   }
94475
94476 }
94477
94478
94479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
94480   unsigned int jresult ;
94481   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94482   bool result;
94483
94484   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94485   {
94486     try {
94487       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);
94488     } catch (std::out_of_range& e) {
94489       {
94490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94491       };
94492     } catch (std::exception& e) {
94493       {
94494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94495       };
94496     } catch (Dali::DaliException e) {
94497       {
94498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94499       };
94500     } catch (...) {
94501       {
94502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94503       };
94504     }
94505   }
94506
94507   jresult = result;
94508   return jresult;
94509 }
94510
94511
94512 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
94513   unsigned long jresult ;
94514   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94515   std::size_t result;
94516
94517   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94518   {
94519     try {
94520       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);
94521     } catch (std::out_of_range& e) {
94522       {
94523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94524       };
94525     } catch (std::exception& e) {
94526       {
94527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94528       };
94529     } catch (Dali::DaliException e) {
94530       {
94531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94532       };
94533     } catch (...) {
94534       {
94535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94536       };
94537     }
94538   }
94539
94540   jresult = (unsigned long)result;
94541   return jresult;
94542 }
94543
94544
94545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
94546   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94547   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
94548
94549   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94550   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
94551   {
94552     try {
94553       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
94554     } catch (std::out_of_range& e) {
94555       {
94556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94557       };
94558     } catch (std::exception& e) {
94559       {
94560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94561       };
94562     } catch (Dali::DaliException e) {
94563       {
94564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94565       };
94566     } catch (...) {
94567       {
94568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94569       };
94570     }
94571   }
94572
94573 }
94574
94575
94576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
94577   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94578   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
94579
94580   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94581   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
94582   {
94583     try {
94584       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
94585     } catch (std::out_of_range& e) {
94586       {
94587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94588       };
94589     } catch (std::exception& e) {
94590       {
94591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94592       };
94593     } catch (Dali::DaliException e) {
94594       {
94595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94596       };
94597     } catch (...) {
94598       {
94599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94600       };
94601     }
94602   }
94603
94604 }
94605
94606
94607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
94608   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94609   Dali::Actor arg2 ;
94610   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
94611   Dali::Actor *argp2 ;
94612
94613   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94614   argp2 = (Dali::Actor *)jarg2;
94615   if (!argp2) {
94616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94617     return ;
94618   }
94619   arg2 = *argp2;
94620   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
94621   {
94622     try {
94623       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
94624     } catch (std::out_of_range& e) {
94625       {
94626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94627       };
94628     } catch (std::exception& e) {
94629       {
94630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94631       };
94632     } catch (Dali::DaliException e) {
94633       {
94634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94635       };
94636     } catch (...) {
94637       {
94638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94639       };
94640     }
94641   }
94642
94643 }
94644
94645
94646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
94647   void * jresult ;
94648   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
94649
94650   {
94651     try {
94652       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
94653     } catch (std::out_of_range& e) {
94654       {
94655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94656       };
94657     } catch (std::exception& e) {
94658       {
94659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94660       };
94661     } catch (Dali::DaliException e) {
94662       {
94663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94664       };
94665     } catch (...) {
94666       {
94667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94668       };
94669     }
94670   }
94671
94672   jresult = (void *)result;
94673   return jresult;
94674 }
94675
94676
94677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
94678   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94679
94680   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94681   {
94682     try {
94683       delete arg1;
94684     } catch (std::out_of_range& e) {
94685       {
94686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94687       };
94688     } catch (std::exception& e) {
94689       {
94690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94691       };
94692     } catch (Dali::DaliException e) {
94693       {
94694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94695       };
94696     } catch (...) {
94697       {
94698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94699       };
94700     }
94701   }
94702
94703 }
94704
94705
94706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
94707   unsigned int jresult ;
94708   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94709   bool result;
94710
94711   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94712   {
94713     try {
94714       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
94715     } catch (std::out_of_range& e) {
94716       {
94717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94718       };
94719     } catch (std::exception& e) {
94720       {
94721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94722       };
94723     } catch (Dali::DaliException e) {
94724       {
94725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94726       };
94727     } catch (...) {
94728       {
94729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94730       };
94731     }
94732   }
94733
94734   jresult = result;
94735   return jresult;
94736 }
94737
94738
94739 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
94740   unsigned long jresult ;
94741   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94742   std::size_t result;
94743
94744   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94745   {
94746     try {
94747       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
94748     } catch (std::out_of_range& e) {
94749       {
94750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94751       };
94752     } catch (std::exception& e) {
94753       {
94754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94755       };
94756     } catch (Dali::DaliException e) {
94757       {
94758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94759       };
94760     } catch (...) {
94761       {
94762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94763       };
94764     }
94765   }
94766
94767   jresult = (unsigned long)result;
94768   return jresult;
94769 }
94770
94771
94772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
94773   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94774   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
94775
94776   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94777   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
94778   {
94779     try {
94780       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
94781     } catch (std::out_of_range& e) {
94782       {
94783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94784       };
94785     } catch (std::exception& e) {
94786       {
94787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94788       };
94789     } catch (Dali::DaliException e) {
94790       {
94791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94792       };
94793     } catch (...) {
94794       {
94795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94796       };
94797     }
94798   }
94799
94800 }
94801
94802
94803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
94804   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94805   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
94806
94807   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94808   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
94809   {
94810     try {
94811       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
94812     } catch (std::out_of_range& e) {
94813       {
94814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94815       };
94816     } catch (std::exception& e) {
94817       {
94818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94819       };
94820     } catch (Dali::DaliException e) {
94821       {
94822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94823       };
94824     } catch (...) {
94825       {
94826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94827       };
94828     }
94829   }
94830
94831 }
94832
94833
94834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
94835   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94836   Dali::Actor arg2 ;
94837   Dali::Actor arg3 ;
94838   Dali::Actor *argp2 ;
94839   Dali::Actor *argp3 ;
94840
94841   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94842   argp2 = (Dali::Actor *)jarg2;
94843   if (!argp2) {
94844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94845     return ;
94846   }
94847   arg2 = *argp2;
94848   argp3 = (Dali::Actor *)jarg3;
94849   if (!argp3) {
94850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94851     return ;
94852   }
94853   arg3 = *argp3;
94854   {
94855     try {
94856       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
94857     } catch (std::out_of_range& e) {
94858       {
94859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94860       };
94861     } catch (std::exception& e) {
94862       {
94863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94864       };
94865     } catch (Dali::DaliException e) {
94866       {
94867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94868       };
94869     } catch (...) {
94870       {
94871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94872       };
94873     }
94874   }
94875
94876 }
94877
94878
94879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
94880   void * jresult ;
94881   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
94882
94883   {
94884     try {
94885       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
94886     } catch (std::out_of_range& e) {
94887       {
94888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94889       };
94890     } catch (std::exception& e) {
94891       {
94892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94893       };
94894     } catch (Dali::DaliException e) {
94895       {
94896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94897       };
94898     } catch (...) {
94899       {
94900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94901       };
94902     }
94903   }
94904
94905   jresult = (void *)result;
94906   return jresult;
94907 }
94908
94909
94910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
94911   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94912
94913   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94914   {
94915     try {
94916       delete arg1;
94917     } catch (std::out_of_range& e) {
94918       {
94919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94920       };
94921     } catch (std::exception& e) {
94922       {
94923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94924       };
94925     } catch (Dali::DaliException e) {
94926       {
94927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94928       };
94929     } catch (...) {
94930       {
94931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94932       };
94933     }
94934   }
94935
94936 }
94937
94938
94939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
94940   unsigned int jresult ;
94941   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94942   bool result;
94943
94944   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94945   {
94946     try {
94947       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
94948     } catch (std::out_of_range& e) {
94949       {
94950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94951       };
94952     } catch (std::exception& e) {
94953       {
94954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94955       };
94956     } catch (Dali::DaliException e) {
94957       {
94958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94959       };
94960     } catch (...) {
94961       {
94962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94963       };
94964     }
94965   }
94966
94967   jresult = result;
94968   return jresult;
94969 }
94970
94971
94972 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
94973   unsigned long jresult ;
94974   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94975   std::size_t result;
94976
94977   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94978   {
94979     try {
94980       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
94981     } catch (std::out_of_range& e) {
94982       {
94983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94984       };
94985     } catch (std::exception& e) {
94986       {
94987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94988       };
94989     } catch (Dali::DaliException e) {
94990       {
94991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94992       };
94993     } catch (...) {
94994       {
94995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94996       };
94997     }
94998   }
94999
95000   jresult = (unsigned long)result;
95001   return jresult;
95002 }
95003
95004
95005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
95006   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95007   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
95008
95009   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95010   arg2 = (void (*)(Dali::Actor,bool))jarg2;
95011   {
95012     try {
95013       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
95014     } catch (std::out_of_range& e) {
95015       {
95016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95017       };
95018     } catch (std::exception& e) {
95019       {
95020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95021       };
95022     } catch (Dali::DaliException e) {
95023       {
95024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95025       };
95026     } catch (...) {
95027       {
95028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95029       };
95030     }
95031   }
95032
95033 }
95034
95035
95036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95037   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95038   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
95039
95040   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95041   arg2 = (void (*)(Dali::Actor,bool))jarg2;
95042   {
95043     try {
95044       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
95045     } catch (std::out_of_range& e) {
95046       {
95047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95048       };
95049     } catch (std::exception& e) {
95050       {
95051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95052       };
95053     } catch (Dali::DaliException e) {
95054       {
95055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95056       };
95057     } catch (...) {
95058       {
95059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95060       };
95061     }
95062   }
95063
95064 }
95065
95066
95067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
95068   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95069   Dali::Actor arg2 ;
95070   bool arg3 ;
95071   Dali::Actor *argp2 ;
95072
95073   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95074   argp2 = (Dali::Actor *)jarg2;
95075   if (!argp2) {
95076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95077     return ;
95078   }
95079   arg2 = *argp2;
95080   arg3 = jarg3 ? true : false;
95081   {
95082     try {
95083       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
95084     } catch (std::out_of_range& e) {
95085       {
95086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95087       };
95088     } catch (std::exception& e) {
95089       {
95090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95091       };
95092     } catch (Dali::DaliException e) {
95093       {
95094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95095       };
95096     } catch (...) {
95097       {
95098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95099       };
95100     }
95101   }
95102
95103 }
95104
95105
95106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
95107   void * jresult ;
95108   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
95109
95110   {
95111     try {
95112       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
95113     } catch (std::out_of_range& e) {
95114       {
95115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95116       };
95117     } catch (std::exception& e) {
95118       {
95119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95120       };
95121     } catch (Dali::DaliException e) {
95122       {
95123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95124       };
95125     } catch (...) {
95126       {
95127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95128       };
95129     }
95130   }
95131
95132   jresult = (void *)result;
95133   return jresult;
95134 }
95135
95136
95137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
95138   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95139
95140   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95141   {
95142     try {
95143       delete arg1;
95144     } catch (std::out_of_range& e) {
95145       {
95146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95147       };
95148     } catch (std::exception& e) {
95149       {
95150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95151       };
95152     } catch (Dali::DaliException e) {
95153       {
95154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95155       };
95156     } catch (...) {
95157       {
95158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95159       };
95160     }
95161   }
95162
95163 }
95164
95165
95166 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
95167   unsigned int jresult ;
95168   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95169   bool result;
95170
95171   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95172   {
95173     try {
95174       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);
95175     } catch (std::out_of_range& e) {
95176       {
95177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95178       };
95179     } catch (std::exception& e) {
95180       {
95181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95182       };
95183     } catch (Dali::DaliException e) {
95184       {
95185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95186       };
95187     } catch (...) {
95188       {
95189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95190       };
95191     }
95192   }
95193
95194   jresult = result;
95195   return jresult;
95196 }
95197
95198
95199 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
95200   unsigned long jresult ;
95201   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95202   std::size_t result;
95203
95204   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95205   {
95206     try {
95207       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);
95208     } catch (std::out_of_range& e) {
95209       {
95210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95211       };
95212     } catch (std::exception& e) {
95213       {
95214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95215       };
95216     } catch (Dali::DaliException e) {
95217       {
95218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95219       };
95220     } catch (...) {
95221       {
95222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95223       };
95224     }
95225   }
95226
95227   jresult = (unsigned long)result;
95228   return jresult;
95229 }
95230
95231
95232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
95233   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95234   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
95235
95236   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95237   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
95238   {
95239     try {
95240       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
95241     } catch (std::out_of_range& e) {
95242       {
95243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95244       };
95245     } catch (std::exception& e) {
95246       {
95247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95248       };
95249     } catch (Dali::DaliException e) {
95250       {
95251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95252       };
95253     } catch (...) {
95254       {
95255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95256       };
95257     }
95258   }
95259
95260 }
95261
95262
95263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95264   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95265   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
95266
95267   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95268   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
95269   {
95270     try {
95271       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
95272     } catch (std::out_of_range& e) {
95273       {
95274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95275       };
95276     } catch (std::exception& e) {
95277       {
95278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95279       };
95280     } catch (Dali::DaliException e) {
95281       {
95282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95283       };
95284     } catch (...) {
95285       {
95286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95287       };
95288     }
95289   }
95290
95291 }
95292
95293
95294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95295   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95296   Dali::Toolkit::StyleManager arg2 ;
95297   Dali::StyleChange::Type arg3 ;
95298   Dali::Toolkit::StyleManager *argp2 ;
95299
95300   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95301   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
95302   if (!argp2) {
95303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
95304     return ;
95305   }
95306   arg2 = *argp2;
95307   arg3 = (Dali::StyleChange::Type)jarg3;
95308   {
95309     try {
95310       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
95311     } catch (std::out_of_range& e) {
95312       {
95313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95314       };
95315     } catch (std::exception& e) {
95316       {
95317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95318       };
95319     } catch (Dali::DaliException e) {
95320       {
95321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95322       };
95323     } catch (...) {
95324       {
95325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95326       };
95327     }
95328   }
95329
95330 }
95331
95332
95333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
95334   void * jresult ;
95335   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
95336
95337   {
95338     try {
95339       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
95340     } catch (std::out_of_range& e) {
95341       {
95342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95343       };
95344     } catch (std::exception& e) {
95345       {
95346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95347       };
95348     } catch (Dali::DaliException e) {
95349       {
95350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95351       };
95352     } catch (...) {
95353       {
95354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95355       };
95356     }
95357   }
95358
95359   jresult = (void *)result;
95360   return jresult;
95361 }
95362
95363
95364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
95365   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95366
95367   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95368   {
95369     try {
95370       delete arg1;
95371     } catch (std::out_of_range& e) {
95372       {
95373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95374       };
95375     } catch (std::exception& e) {
95376       {
95377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95378       };
95379     } catch (Dali::DaliException e) {
95380       {
95381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95382       };
95383     } catch (...) {
95384       {
95385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95386       };
95387     }
95388   }
95389
95390 }
95391
95392
95393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
95394   unsigned int jresult ;
95395   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95396   bool result;
95397
95398   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95399   {
95400     try {
95401       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
95402     } catch (std::out_of_range& e) {
95403       {
95404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95405       };
95406     } catch (std::exception& e) {
95407       {
95408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95409       };
95410     } catch (Dali::DaliException e) {
95411       {
95412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95413       };
95414     } catch (...) {
95415       {
95416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95417       };
95418     }
95419   }
95420
95421   jresult = result;
95422   return jresult;
95423 }
95424
95425
95426 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
95427   unsigned long jresult ;
95428   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95429   std::size_t result;
95430
95431   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95432   {
95433     try {
95434       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
95435     } catch (std::out_of_range& e) {
95436       {
95437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95438       };
95439     } catch (std::exception& e) {
95440       {
95441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95442       };
95443     } catch (Dali::DaliException e) {
95444       {
95445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95446       };
95447     } catch (...) {
95448       {
95449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95450       };
95451     }
95452   }
95453
95454   jresult = (unsigned long)result;
95455   return jresult;
95456 }
95457
95458
95459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
95460   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95461   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
95462
95463   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95464   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
95465   {
95466     try {
95467       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
95468     } catch (std::out_of_range& e) {
95469       {
95470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95471       };
95472     } catch (std::exception& e) {
95473       {
95474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95475       };
95476     } catch (Dali::DaliException e) {
95477       {
95478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95479       };
95480     } catch (...) {
95481       {
95482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95483       };
95484     }
95485   }
95486
95487 }
95488
95489
95490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
95491   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95492   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
95493
95494   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95495   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
95496   {
95497     try {
95498       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
95499     } catch (std::out_of_range& e) {
95500       {
95501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95502       };
95503     } catch (std::exception& e) {
95504       {
95505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95506       };
95507     } catch (Dali::DaliException e) {
95508       {
95509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95510       };
95511     } catch (...) {
95512       {
95513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95514       };
95515     }
95516   }
95517
95518 }
95519
95520
95521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
95522   unsigned int jresult ;
95523   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95524   Dali::Toolkit::Button arg2 ;
95525   Dali::Toolkit::Button *argp2 ;
95526   bool result;
95527
95528   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95529   argp2 = (Dali::Toolkit::Button *)jarg2;
95530   if (!argp2) {
95531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
95532     return 0;
95533   }
95534   arg2 = *argp2;
95535   {
95536     try {
95537       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
95538     } catch (std::out_of_range& e) {
95539       {
95540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95541       };
95542     } catch (std::exception& e) {
95543       {
95544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95545       };
95546     } catch (Dali::DaliException e) {
95547       {
95548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95549       };
95550     } catch (...) {
95551       {
95552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95553       };
95554     }
95555   }
95556
95557   jresult = result;
95558   return jresult;
95559 }
95560
95561
95562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
95563   void * jresult ;
95564   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
95565
95566   {
95567     try {
95568       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
95569     } catch (std::out_of_range& e) {
95570       {
95571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95572       };
95573     } catch (std::exception& e) {
95574       {
95575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95576       };
95577     } catch (Dali::DaliException e) {
95578       {
95579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95580       };
95581     } catch (...) {
95582       {
95583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95584       };
95585     }
95586   }
95587
95588   jresult = (void *)result;
95589   return jresult;
95590 }
95591
95592
95593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
95594   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95595
95596   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95597   {
95598     try {
95599       delete arg1;
95600     } catch (std::out_of_range& e) {
95601       {
95602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95603       };
95604     } catch (std::exception& e) {
95605       {
95606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95607       };
95608     } catch (Dali::DaliException e) {
95609       {
95610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95611       };
95612     } catch (...) {
95613       {
95614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95615       };
95616     }
95617   }
95618
95619 }
95620
95621
95622 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
95623   unsigned int jresult ;
95624   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95625   bool result;
95626
95627   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95628   {
95629     try {
95630       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
95631     } catch (std::out_of_range& e) {
95632       {
95633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95634       };
95635     } catch (std::exception& e) {
95636       {
95637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95638       };
95639     } catch (Dali::DaliException e) {
95640       {
95641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95642       };
95643     } catch (...) {
95644       {
95645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95646       };
95647     }
95648   }
95649
95650   jresult = result;
95651   return jresult;
95652 }
95653
95654
95655 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
95656   unsigned long jresult ;
95657   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95658   std::size_t result;
95659
95660   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95661   {
95662     try {
95663       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
95664     } catch (std::out_of_range& e) {
95665       {
95666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95667       };
95668     } catch (std::exception& e) {
95669       {
95670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95671       };
95672     } catch (Dali::DaliException e) {
95673       {
95674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95675       };
95676     } catch (...) {
95677       {
95678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95679       };
95680     }
95681   }
95682
95683   jresult = (unsigned long)result;
95684   return jresult;
95685 }
95686
95687
95688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
95689   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95690   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
95691
95692   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95693   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
95694   {
95695     try {
95696       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
95697     } catch (std::out_of_range& e) {
95698       {
95699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95700       };
95701     } catch (std::exception& e) {
95702       {
95703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95704       };
95705     } catch (Dali::DaliException e) {
95706       {
95707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95708       };
95709     } catch (...) {
95710       {
95711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95712       };
95713     }
95714   }
95715
95716 }
95717
95718
95719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
95720   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95721   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
95722
95723   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95724   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
95725   {
95726     try {
95727       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
95728     } catch (std::out_of_range& e) {
95729       {
95730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95731       };
95732     } catch (std::exception& e) {
95733       {
95734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95735       };
95736     } catch (Dali::DaliException e) {
95737       {
95738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95739       };
95740     } catch (...) {
95741       {
95742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95743       };
95744     }
95745   }
95746
95747 }
95748
95749
95750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
95751   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95752   Dali::Toolkit::GaussianBlurView arg2 ;
95753   Dali::Toolkit::GaussianBlurView *argp2 ;
95754
95755   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95756   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
95757   if (!argp2) {
95758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
95759     return ;
95760   }
95761   arg2 = *argp2;
95762   {
95763     try {
95764       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
95765     } catch (std::out_of_range& e) {
95766       {
95767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95768       };
95769     } catch (std::exception& e) {
95770       {
95771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95772       };
95773     } catch (Dali::DaliException e) {
95774       {
95775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95776       };
95777     } catch (...) {
95778       {
95779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95780       };
95781     }
95782   }
95783
95784 }
95785
95786
95787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
95788   void * jresult ;
95789   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
95790
95791   {
95792     try {
95793       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
95794     } catch (std::out_of_range& e) {
95795       {
95796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95797       };
95798     } catch (std::exception& e) {
95799       {
95800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95801       };
95802     } catch (Dali::DaliException e) {
95803       {
95804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95805       };
95806     } catch (...) {
95807       {
95808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95809       };
95810     }
95811   }
95812
95813   jresult = (void *)result;
95814   return jresult;
95815 }
95816
95817
95818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
95819   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95820
95821   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95822   {
95823     try {
95824       delete arg1;
95825     } catch (std::out_of_range& e) {
95826       {
95827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95828       };
95829     } catch (std::exception& e) {
95830       {
95831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95832       };
95833     } catch (Dali::DaliException e) {
95834       {
95835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95836       };
95837     } catch (...) {
95838       {
95839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95840       };
95841     }
95842   }
95843
95844 }
95845
95846
95847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
95848   unsigned int jresult ;
95849   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95850   bool result;
95851
95852   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95853   {
95854     try {
95855       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);
95856     } catch (std::out_of_range& e) {
95857       {
95858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95859       };
95860     } catch (std::exception& e) {
95861       {
95862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95863       };
95864     } catch (Dali::DaliException e) {
95865       {
95866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95867       };
95868     } catch (...) {
95869       {
95870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95871       };
95872     }
95873   }
95874
95875   jresult = result;
95876   return jresult;
95877 }
95878
95879
95880 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
95881   unsigned long jresult ;
95882   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95883   std::size_t result;
95884
95885   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95886   {
95887     try {
95888       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);
95889     } catch (std::out_of_range& e) {
95890       {
95891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95892       };
95893     } catch (std::exception& e) {
95894       {
95895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95896       };
95897     } catch (Dali::DaliException e) {
95898       {
95899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95900       };
95901     } catch (...) {
95902       {
95903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95904       };
95905     }
95906   }
95907
95908   jresult = (unsigned long)result;
95909   return jresult;
95910 }
95911
95912
95913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
95914   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95915   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
95916
95917   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95918   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
95919   {
95920     try {
95921       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
95922     } catch (std::out_of_range& e) {
95923       {
95924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95925       };
95926     } catch (std::exception& e) {
95927       {
95928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95929       };
95930     } catch (Dali::DaliException e) {
95931       {
95932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95933       };
95934     } catch (...) {
95935       {
95936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95937       };
95938     }
95939   }
95940
95941 }
95942
95943
95944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
95945   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95946   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
95947
95948   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95949   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
95950   {
95951     try {
95952       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
95953     } catch (std::out_of_range& e) {
95954       {
95955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95956       };
95957     } catch (std::exception& e) {
95958       {
95959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95960       };
95961     } catch (Dali::DaliException e) {
95962       {
95963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95964       };
95965     } catch (...) {
95966       {
95967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95968       };
95969     }
95970   }
95971
95972 }
95973
95974
95975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
95976   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95977   Dali::Toolkit::PageTurnView arg2 ;
95978   unsigned int arg3 ;
95979   bool arg4 ;
95980   Dali::Toolkit::PageTurnView *argp2 ;
95981
95982   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95983   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
95984   if (!argp2) {
95985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
95986     return ;
95987   }
95988   arg2 = *argp2;
95989   arg3 = (unsigned int)jarg3;
95990   arg4 = jarg4 ? true : false;
95991   {
95992     try {
95993       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
95994     } catch (std::out_of_range& e) {
95995       {
95996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95997       };
95998     } catch (std::exception& e) {
95999       {
96000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96001       };
96002     } catch (Dali::DaliException e) {
96003       {
96004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96005       };
96006     } catch (...) {
96007       {
96008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96009       };
96010     }
96011   }
96012
96013 }
96014
96015
96016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
96017   void * jresult ;
96018   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
96019
96020   {
96021     try {
96022       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
96023     } catch (std::out_of_range& e) {
96024       {
96025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96026       };
96027     } catch (std::exception& e) {
96028       {
96029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96030       };
96031     } catch (Dali::DaliException e) {
96032       {
96033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96034       };
96035     } catch (...) {
96036       {
96037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96038       };
96039     }
96040   }
96041
96042   jresult = (void *)result;
96043   return jresult;
96044 }
96045
96046
96047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
96048   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96049
96050   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96051   {
96052     try {
96053       delete arg1;
96054     } catch (std::out_of_range& e) {
96055       {
96056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96057       };
96058     } catch (std::exception& e) {
96059       {
96060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96061       };
96062     } catch (Dali::DaliException e) {
96063       {
96064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96065       };
96066     } catch (...) {
96067       {
96068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96069       };
96070     }
96071   }
96072
96073 }
96074
96075
96076 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
96077   unsigned int jresult ;
96078   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96079   bool result;
96080
96081   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96082   {
96083     try {
96084       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
96085     } catch (std::out_of_range& e) {
96086       {
96087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96088       };
96089     } catch (std::exception& e) {
96090       {
96091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96092       };
96093     } catch (Dali::DaliException e) {
96094       {
96095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96096       };
96097     } catch (...) {
96098       {
96099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96100       };
96101     }
96102   }
96103
96104   jresult = result;
96105   return jresult;
96106 }
96107
96108
96109 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
96110   unsigned long jresult ;
96111   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96112   std::size_t result;
96113
96114   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96115   {
96116     try {
96117       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
96118     } catch (std::out_of_range& e) {
96119       {
96120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96121       };
96122     } catch (std::exception& e) {
96123       {
96124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96125       };
96126     } catch (Dali::DaliException e) {
96127       {
96128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96129       };
96130     } catch (...) {
96131       {
96132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96133       };
96134     }
96135   }
96136
96137   jresult = (unsigned long)result;
96138   return jresult;
96139 }
96140
96141
96142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
96143   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96144   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
96145
96146   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96147   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
96148   {
96149     try {
96150       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
96151     } catch (std::out_of_range& e) {
96152       {
96153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96154       };
96155     } catch (std::exception& e) {
96156       {
96157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96158       };
96159     } catch (Dali::DaliException e) {
96160       {
96161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96162       };
96163     } catch (...) {
96164       {
96165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96166       };
96167     }
96168   }
96169
96170 }
96171
96172
96173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
96174   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96175   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
96176
96177   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96178   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
96179   {
96180     try {
96181       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
96182     } catch (std::out_of_range& e) {
96183       {
96184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96185       };
96186     } catch (std::exception& e) {
96187       {
96188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96189       };
96190     } catch (Dali::DaliException e) {
96191       {
96192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96193       };
96194     } catch (...) {
96195       {
96196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96197       };
96198     }
96199   }
96200
96201 }
96202
96203
96204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
96205   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96206   Dali::Toolkit::PageTurnView arg2 ;
96207   Dali::Toolkit::PageTurnView *argp2 ;
96208
96209   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96210   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
96211   if (!argp2) {
96212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
96213     return ;
96214   }
96215   arg2 = *argp2;
96216   {
96217     try {
96218       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
96219     } catch (std::out_of_range& e) {
96220       {
96221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96222       };
96223     } catch (std::exception& e) {
96224       {
96225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96226       };
96227     } catch (Dali::DaliException e) {
96228       {
96229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96230       };
96231     } catch (...) {
96232       {
96233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96234       };
96235     }
96236   }
96237
96238 }
96239
96240
96241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
96242   void * jresult ;
96243   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
96244
96245   {
96246     try {
96247       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
96248     } catch (std::out_of_range& e) {
96249       {
96250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96251       };
96252     } catch (std::exception& e) {
96253       {
96254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96255       };
96256     } catch (Dali::DaliException e) {
96257       {
96258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96259       };
96260     } catch (...) {
96261       {
96262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96263       };
96264     }
96265   }
96266
96267   jresult = (void *)result;
96268   return jresult;
96269 }
96270
96271
96272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
96273   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96274
96275   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96276   {
96277     try {
96278       delete arg1;
96279     } catch (std::out_of_range& e) {
96280       {
96281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96282       };
96283     } catch (std::exception& e) {
96284       {
96285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96286       };
96287     } catch (Dali::DaliException e) {
96288       {
96289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96290       };
96291     } catch (...) {
96292       {
96293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96294       };
96295     }
96296   }
96297
96298 }
96299
96300
96301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
96302   unsigned int jresult ;
96303   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96304   bool result;
96305
96306   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96307   {
96308     try {
96309       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);
96310     } catch (std::out_of_range& e) {
96311       {
96312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96313       };
96314     } catch (std::exception& e) {
96315       {
96316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96317       };
96318     } catch (Dali::DaliException e) {
96319       {
96320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96321       };
96322     } catch (...) {
96323       {
96324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96325       };
96326     }
96327   }
96328
96329   jresult = result;
96330   return jresult;
96331 }
96332
96333
96334 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
96335   unsigned long jresult ;
96336   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96337   std::size_t result;
96338
96339   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96340   {
96341     try {
96342       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);
96343     } catch (std::out_of_range& e) {
96344       {
96345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96346       };
96347     } catch (std::exception& e) {
96348       {
96349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96350       };
96351     } catch (Dali::DaliException e) {
96352       {
96353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96354       };
96355     } catch (...) {
96356       {
96357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96358       };
96359     }
96360   }
96361
96362   jresult = (unsigned long)result;
96363   return jresult;
96364 }
96365
96366
96367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
96368   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96369   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
96370
96371   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96372   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
96373   {
96374     try {
96375       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
96376     } catch (std::out_of_range& e) {
96377       {
96378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96379       };
96380     } catch (std::exception& e) {
96381       {
96382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96383       };
96384     } catch (Dali::DaliException e) {
96385       {
96386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96387       };
96388     } catch (...) {
96389       {
96390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96391       };
96392     }
96393   }
96394
96395 }
96396
96397
96398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96399   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96400   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
96401
96402   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96403   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
96404   {
96405     try {
96406       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
96407     } catch (std::out_of_range& e) {
96408       {
96409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96410       };
96411     } catch (std::exception& e) {
96412       {
96413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96414       };
96415     } catch (Dali::DaliException e) {
96416       {
96417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96418       };
96419     } catch (...) {
96420       {
96421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96422       };
96423     }
96424   }
96425
96426 }
96427
96428
96429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
96430   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96431   Dali::Toolkit::ProgressBar arg2 ;
96432   float arg3 ;
96433   float arg4 ;
96434   Dali::Toolkit::ProgressBar *argp2 ;
96435
96436   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96437   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
96438   if (!argp2) {
96439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
96440     return ;
96441   }
96442   arg2 = *argp2;
96443   arg3 = (float)jarg3;
96444   arg4 = (float)jarg4;
96445   {
96446     try {
96447       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
96448     } catch (std::out_of_range& e) {
96449       {
96450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96451       };
96452     } catch (std::exception& e) {
96453       {
96454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96455       };
96456     } catch (Dali::DaliException e) {
96457       {
96458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96459       };
96460     } catch (...) {
96461       {
96462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96463       };
96464     }
96465   }
96466
96467 }
96468
96469
96470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
96471   void * jresult ;
96472   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
96473
96474   {
96475     try {
96476       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
96477     } catch (std::out_of_range& e) {
96478       {
96479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96480       };
96481     } catch (std::exception& e) {
96482       {
96483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96484       };
96485     } catch (Dali::DaliException e) {
96486       {
96487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96488       };
96489     } catch (...) {
96490       {
96491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96492       };
96493     }
96494   }
96495
96496   jresult = (void *)result;
96497   return jresult;
96498 }
96499
96500
96501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
96502   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96503
96504   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96505   {
96506     try {
96507       delete arg1;
96508     } catch (std::out_of_range& e) {
96509       {
96510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96511       };
96512     } catch (std::exception& e) {
96513       {
96514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96515       };
96516     } catch (Dali::DaliException e) {
96517       {
96518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96519       };
96520     } catch (...) {
96521       {
96522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96523       };
96524     }
96525   }
96526
96527 }
96528
96529
96530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
96531   unsigned int jresult ;
96532   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96533   bool result;
96534
96535   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96536   {
96537     try {
96538       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);
96539     } catch (std::out_of_range& e) {
96540       {
96541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96542       };
96543     } catch (std::exception& e) {
96544       {
96545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96546       };
96547     } catch (Dali::DaliException e) {
96548       {
96549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96550       };
96551     } catch (...) {
96552       {
96553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96554       };
96555     }
96556   }
96557
96558   jresult = result;
96559   return jresult;
96560 }
96561
96562
96563 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
96564   unsigned long jresult ;
96565   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96566   std::size_t result;
96567
96568   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96569   {
96570     try {
96571       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);
96572     } catch (std::out_of_range& e) {
96573       {
96574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96575       };
96576     } catch (std::exception& e) {
96577       {
96578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96579       };
96580     } catch (Dali::DaliException e) {
96581       {
96582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96583       };
96584     } catch (...) {
96585       {
96586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96587       };
96588     }
96589   }
96590
96591   jresult = (unsigned long)result;
96592   return jresult;
96593 }
96594
96595
96596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
96597   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96598   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
96599
96600   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96601   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
96602   {
96603     try {
96604       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
96605     } catch (std::out_of_range& e) {
96606       {
96607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96608       };
96609     } catch (std::exception& e) {
96610       {
96611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96612       };
96613     } catch (Dali::DaliException e) {
96614       {
96615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96616       };
96617     } catch (...) {
96618       {
96619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96620       };
96621     }
96622   }
96623
96624 }
96625
96626
96627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
96628   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96629   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
96630
96631   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96632   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
96633   {
96634     try {
96635       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
96636     } catch (std::out_of_range& e) {
96637       {
96638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96639       };
96640     } catch (std::exception& e) {
96641       {
96642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96643       };
96644     } catch (Dali::DaliException e) {
96645       {
96646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96647       };
96648     } catch (...) {
96649       {
96650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96651       };
96652     }
96653   }
96654
96655 }
96656
96657
96658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
96659   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96660   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
96661
96662   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96663   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
96664   if (!arg2) {
96665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
96666     return ;
96667   }
96668   {
96669     try {
96670       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
96671     } catch (std::out_of_range& e) {
96672       {
96673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96674       };
96675     } catch (std::exception& e) {
96676       {
96677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96678       };
96679     } catch (Dali::DaliException e) {
96680       {
96681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96682       };
96683     } catch (...) {
96684       {
96685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96686       };
96687     }
96688   }
96689
96690 }
96691
96692
96693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
96694   void * jresult ;
96695   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
96696
96697   {
96698     try {
96699       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
96700     } catch (std::out_of_range& e) {
96701       {
96702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96703       };
96704     } catch (std::exception& e) {
96705       {
96706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96707       };
96708     } catch (Dali::DaliException e) {
96709       {
96710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96711       };
96712     } catch (...) {
96713       {
96714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96715       };
96716     }
96717   }
96718
96719   jresult = (void *)result;
96720   return jresult;
96721 }
96722
96723
96724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
96725   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96726
96727   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96728   {
96729     try {
96730       delete arg1;
96731     } catch (std::out_of_range& e) {
96732       {
96733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96734       };
96735     } catch (std::exception& e) {
96736       {
96737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96738       };
96739     } catch (Dali::DaliException e) {
96740       {
96741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96742       };
96743     } catch (...) {
96744       {
96745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96746       };
96747     }
96748   }
96749
96750 }
96751
96752
96753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
96754   unsigned int jresult ;
96755   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96756   bool result;
96757
96758   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96759   {
96760     try {
96761       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
96762     } catch (std::out_of_range& e) {
96763       {
96764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96765       };
96766     } catch (std::exception& e) {
96767       {
96768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96769       };
96770     } catch (Dali::DaliException e) {
96771       {
96772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96773       };
96774     } catch (...) {
96775       {
96776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96777       };
96778     }
96779   }
96780
96781   jresult = result;
96782   return jresult;
96783 }
96784
96785
96786 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
96787   unsigned long jresult ;
96788   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96789   std::size_t result;
96790
96791   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96792   {
96793     try {
96794       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
96795     } catch (std::out_of_range& e) {
96796       {
96797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96798       };
96799     } catch (std::exception& e) {
96800       {
96801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96802       };
96803     } catch (Dali::DaliException e) {
96804       {
96805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96806       };
96807     } catch (...) {
96808       {
96809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96810       };
96811     }
96812   }
96813
96814   jresult = (unsigned long)result;
96815   return jresult;
96816 }
96817
96818
96819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
96820   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96821   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
96822
96823   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96824   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
96825   {
96826     try {
96827       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
96828     } catch (std::out_of_range& e) {
96829       {
96830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96831       };
96832     } catch (std::exception& e) {
96833       {
96834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96835       };
96836     } catch (Dali::DaliException e) {
96837       {
96838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96839       };
96840     } catch (...) {
96841       {
96842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96843       };
96844     }
96845   }
96846
96847 }
96848
96849
96850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
96851   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96852   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
96853
96854   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96855   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
96856   {
96857     try {
96858       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
96859     } catch (std::out_of_range& e) {
96860       {
96861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96862       };
96863     } catch (std::exception& e) {
96864       {
96865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96866       };
96867     } catch (Dali::DaliException e) {
96868       {
96869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96870       };
96871     } catch (...) {
96872       {
96873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96874       };
96875     }
96876   }
96877
96878 }
96879
96880
96881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
96882   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96883   Dali::Vector2 *arg2 = 0 ;
96884
96885   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96886   arg2 = (Dali::Vector2 *)jarg2;
96887   if (!arg2) {
96888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
96889     return ;
96890   }
96891   {
96892     try {
96893       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
96894     } catch (std::out_of_range& e) {
96895       {
96896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96897       };
96898     } catch (std::exception& e) {
96899       {
96900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96901       };
96902     } catch (Dali::DaliException e) {
96903       {
96904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96905       };
96906     } catch (...) {
96907       {
96908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96909       };
96910     }
96911   }
96912
96913 }
96914
96915
96916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
96917   void * jresult ;
96918   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
96919
96920   {
96921     try {
96922       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
96923     } catch (std::out_of_range& e) {
96924       {
96925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96926       };
96927     } catch (std::exception& e) {
96928       {
96929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96930       };
96931     } catch (Dali::DaliException e) {
96932       {
96933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96934       };
96935     } catch (...) {
96936       {
96937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96938       };
96939     }
96940   }
96941
96942   jresult = (void *)result;
96943   return jresult;
96944 }
96945
96946
96947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
96948   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96949
96950   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96951   {
96952     try {
96953       delete arg1;
96954     } catch (std::out_of_range& e) {
96955       {
96956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96957       };
96958     } catch (std::exception& e) {
96959       {
96960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96961       };
96962     } catch (Dali::DaliException e) {
96963       {
96964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96965       };
96966     } catch (...) {
96967       {
96968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96969       };
96970     }
96971   }
96972
96973 }
96974
96975
96976
96977 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
96978   unsigned int jresult ;
96979   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96980   bool result;
96981
96982   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96983   {
96984     try {
96985       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);
96986     } catch (std::out_of_range& e) {
96987       {
96988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96989       };
96990     } catch (std::exception& e) {
96991       {
96992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96993       };
96994     } catch (Dali::DaliException e) {
96995       {
96996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96997       };
96998     } catch (...) {
96999       {
97000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97001       };
97002     }
97003   }
97004
97005   jresult = result;
97006   return jresult;
97007 }
97008
97009
97010 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
97011   unsigned long jresult ;
97012   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97013   std::size_t result;
97014
97015   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97016   {
97017     try {
97018       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);
97019     } catch (std::out_of_range& e) {
97020       {
97021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97022       };
97023     } catch (std::exception& e) {
97024       {
97025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97026       };
97027     } catch (Dali::DaliException e) {
97028       {
97029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97030       };
97031     } catch (...) {
97032       {
97033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97034       };
97035     }
97036   }
97037
97038   jresult = (unsigned long)result;
97039   return jresult;
97040 }
97041
97042
97043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
97044   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97045   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
97046
97047   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97048   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
97049   {
97050     try {
97051       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97052     } catch (std::out_of_range& e) {
97053       {
97054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97055       };
97056     } catch (std::exception& e) {
97057       {
97058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97059       };
97060     } catch (Dali::DaliException e) {
97061       {
97062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97063       };
97064     } catch (...) {
97065       {
97066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97067       };
97068     }
97069   }
97070
97071 }
97072
97073
97074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
97075   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97076   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
97077
97078   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97079   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
97080   {
97081     try {
97082       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97083     } catch (std::out_of_range& e) {
97084       {
97085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97086       };
97087     } catch (std::exception& e) {
97088       {
97089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97090       };
97091     } catch (Dali::DaliException e) {
97092       {
97093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97094       };
97095     } catch (...) {
97096       {
97097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97098       };
97099     }
97100   }
97101
97102 }
97103
97104
97105 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
97106   unsigned int jresult ;
97107   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97108   Dali::Toolkit::Control arg2 ;
97109   Dali::KeyEvent *arg3 = 0 ;
97110   Dali::Toolkit::Control *argp2 ;
97111   bool result;
97112
97113   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97114   argp2 = (Dali::Toolkit::Control *)jarg2;
97115   if (!argp2) {
97116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
97117     return 0;
97118   }
97119   arg2 = *argp2;
97120   arg3 = (Dali::KeyEvent *)jarg3;
97121   if (!arg3) {
97122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
97123     return 0;
97124   }
97125   {
97126     try {
97127       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);
97128     } catch (std::out_of_range& e) {
97129       {
97130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97131       };
97132     } catch (std::exception& e) {
97133       {
97134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97135       };
97136     } catch (Dali::DaliException e) {
97137       {
97138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97139       };
97140     } catch (...) {
97141       {
97142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97143       };
97144     }
97145   }
97146
97147   jresult = result;
97148   return jresult;
97149 }
97150
97151
97152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
97153   void * jresult ;
97154   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
97155
97156   {
97157     try {
97158       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
97159     } catch (std::out_of_range& e) {
97160       {
97161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97162       };
97163     } catch (std::exception& e) {
97164       {
97165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97166       };
97167     } catch (Dali::DaliException e) {
97168       {
97169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97170       };
97171     } catch (...) {
97172       {
97173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97174       };
97175     }
97176   }
97177
97178   jresult = (void *)result;
97179   return jresult;
97180 }
97181
97182
97183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
97184   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97185
97186   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97187   {
97188     try {
97189       delete arg1;
97190     } catch (std::out_of_range& e) {
97191       {
97192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97193       };
97194     } catch (std::exception& e) {
97195       {
97196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97197       };
97198     } catch (Dali::DaliException e) {
97199       {
97200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97201       };
97202     } catch (...) {
97203       {
97204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97205       };
97206     }
97207   }
97208
97209 }
97210
97211
97212 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
97213   unsigned int jresult ;
97214   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97215   bool result;
97216
97217   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97218   {
97219     try {
97220       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97221     } catch (std::out_of_range& e) {
97222       {
97223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97224       };
97225     } catch (std::exception& e) {
97226       {
97227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97228       };
97229     } catch (Dali::DaliException e) {
97230       {
97231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97232       };
97233     } catch (...) {
97234       {
97235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97236       };
97237     }
97238   }
97239
97240   jresult = result;
97241   return jresult;
97242 }
97243
97244
97245 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
97246   unsigned long jresult ;
97247   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97248   std::size_t result;
97249
97250   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97251   {
97252     try {
97253       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97254     } catch (std::out_of_range& e) {
97255       {
97256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97257       };
97258     } catch (std::exception& e) {
97259       {
97260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97261       };
97262     } catch (Dali::DaliException e) {
97263       {
97264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97265       };
97266     } catch (...) {
97267       {
97268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97269       };
97270     }
97271   }
97272
97273   jresult = (unsigned long)result;
97274   return jresult;
97275 }
97276
97277
97278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
97279   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97280   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
97281
97282   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97283   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
97284   {
97285     try {
97286       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
97287     } catch (std::out_of_range& e) {
97288       {
97289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97290       };
97291     } catch (std::exception& e) {
97292       {
97293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97294       };
97295     } catch (Dali::DaliException e) {
97296       {
97297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97298       };
97299     } catch (...) {
97300       {
97301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97302       };
97303     }
97304   }
97305
97306 }
97307
97308
97309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
97310   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97311   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
97312
97313   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97314   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
97315   {
97316     try {
97317       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
97318     } catch (std::out_of_range& e) {
97319       {
97320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97321       };
97322     } catch (std::exception& e) {
97323       {
97324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97325       };
97326     } catch (Dali::DaliException e) {
97327       {
97328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97329       };
97330     } catch (...) {
97331       {
97332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97333       };
97334     }
97335   }
97336
97337 }
97338
97339
97340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
97341   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97342   Dali::Toolkit::Control arg2 ;
97343   Dali::Toolkit::Control *argp2 ;
97344
97345   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97346   argp2 = (Dali::Toolkit::Control *)jarg2;
97347   if (!argp2) {
97348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
97349     return ;
97350   }
97351   arg2 = *argp2;
97352   {
97353     try {
97354       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
97355     } catch (std::out_of_range& e) {
97356       {
97357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97358       };
97359     } catch (std::exception& e) {
97360       {
97361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97362       };
97363     } catch (Dali::DaliException e) {
97364       {
97365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97366       };
97367     } catch (...) {
97368       {
97369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97370       };
97371     }
97372   }
97373
97374 }
97375
97376
97377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
97378   void * jresult ;
97379   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
97380
97381   {
97382     try {
97383       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
97384     } catch (std::out_of_range& e) {
97385       {
97386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97387       };
97388     } catch (std::exception& e) {
97389       {
97390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97391       };
97392     } catch (Dali::DaliException e) {
97393       {
97394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97395       };
97396     } catch (...) {
97397       {
97398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97399       };
97400     }
97401   }
97402
97403   jresult = (void *)result;
97404   return jresult;
97405 }
97406
97407
97408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
97409   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97410
97411   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97412   {
97413     try {
97414       delete arg1;
97415     } catch (std::out_of_range& e) {
97416       {
97417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97418       };
97419     } catch (std::exception& e) {
97420       {
97421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97422       };
97423     } catch (Dali::DaliException e) {
97424       {
97425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97426       };
97427     } catch (...) {
97428       {
97429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97430       };
97431     }
97432   }
97433
97434 }
97435
97436
97437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
97438   unsigned int jresult ;
97439   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97440   bool result;
97441
97442   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97443   {
97444     try {
97445       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
97446     } catch (std::out_of_range& e) {
97447       {
97448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97449       };
97450     } catch (std::exception& e) {
97451       {
97452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97453       };
97454     } catch (Dali::DaliException e) {
97455       {
97456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97457       };
97458     } catch (...) {
97459       {
97460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97461       };
97462     }
97463   }
97464
97465   jresult = result;
97466   return jresult;
97467 }
97468
97469
97470 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
97471   unsigned long jresult ;
97472   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97473   std::size_t result;
97474
97475   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97476   {
97477     try {
97478       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
97479     } catch (std::out_of_range& e) {
97480       {
97481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97482       };
97483     } catch (std::exception& e) {
97484       {
97485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97486       };
97487     } catch (Dali::DaliException e) {
97488       {
97489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97490       };
97491     } catch (...) {
97492       {
97493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97494       };
97495     }
97496   }
97497
97498   jresult = (unsigned long)result;
97499   return jresult;
97500 }
97501
97502
97503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
97504   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97505   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
97506
97507   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97508   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
97509   {
97510     try {
97511       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
97512     } catch (std::out_of_range& e) {
97513       {
97514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97515       };
97516     } catch (std::exception& e) {
97517       {
97518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97519       };
97520     } catch (Dali::DaliException e) {
97521       {
97522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97523       };
97524     } catch (...) {
97525       {
97526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97527       };
97528     }
97529   }
97530
97531 }
97532
97533
97534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
97535   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97536   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
97537
97538   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97539   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
97540   {
97541     try {
97542       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
97543     } catch (std::out_of_range& e) {
97544       {
97545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97546       };
97547     } catch (std::exception& e) {
97548       {
97549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97550       };
97551     } catch (Dali::DaliException e) {
97552       {
97553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97554       };
97555     } catch (...) {
97556       {
97557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97558       };
97559     }
97560   }
97561
97562 }
97563
97564
97565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
97566   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97567   Dali::Toolkit::VideoView *arg2 = 0 ;
97568
97569   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97570   arg2 = (Dali::Toolkit::VideoView *)jarg2;
97571   if (!arg2) {
97572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
97573     return ;
97574   }
97575   {
97576     try {
97577       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
97578     } catch (std::out_of_range& e) {
97579       {
97580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97581       };
97582     } catch (std::exception& e) {
97583       {
97584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97585       };
97586     } catch (Dali::DaliException e) {
97587       {
97588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97589       };
97590     } catch (...) {
97591       {
97592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97593       };
97594     }
97595   }
97596
97597 }
97598
97599
97600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
97601   void * jresult ;
97602   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
97603
97604   {
97605     try {
97606       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
97607     } catch (std::out_of_range& e) {
97608       {
97609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97610       };
97611     } catch (std::exception& e) {
97612       {
97613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97614       };
97615     } catch (Dali::DaliException e) {
97616       {
97617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97618       };
97619     } catch (...) {
97620       {
97621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97622       };
97623     }
97624   }
97625
97626   jresult = (void *)result;
97627   return jresult;
97628 }
97629
97630
97631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
97632   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97633
97634   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97635   {
97636     try {
97637       delete arg1;
97638     } catch (std::out_of_range& e) {
97639       {
97640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97641       };
97642     } catch (std::exception& e) {
97643       {
97644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97645       };
97646     } catch (Dali::DaliException e) {
97647       {
97648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97649       };
97650     } catch (...) {
97651       {
97652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97653       };
97654     }
97655   }
97656
97657 }
97658
97659
97660 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
97661   unsigned int jresult ;
97662   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97663   bool result;
97664
97665   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97666   {
97667     try {
97668       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
97669     } catch (std::out_of_range& e) {
97670       {
97671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97672       };
97673     } catch (std::exception& e) {
97674       {
97675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97676       };
97677     } catch (Dali::DaliException e) {
97678       {
97679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97680       };
97681     } catch (...) {
97682       {
97683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97684       };
97685     }
97686   }
97687
97688   jresult = result;
97689   return jresult;
97690 }
97691
97692
97693 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
97694   unsigned long jresult ;
97695   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97696   std::size_t result;
97697
97698   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97699   {
97700     try {
97701       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
97702     } catch (std::out_of_range& e) {
97703       {
97704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97705       };
97706     } catch (std::exception& e) {
97707       {
97708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97709       };
97710     } catch (Dali::DaliException e) {
97711       {
97712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97713       };
97714     } catch (...) {
97715       {
97716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97717       };
97718     }
97719   }
97720
97721   jresult = (unsigned long)result;
97722   return jresult;
97723 }
97724
97725
97726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97727   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97728   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
97729
97730   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97731   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
97732   {
97733     try {
97734       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
97735     } catch (std::out_of_range& e) {
97736       {
97737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97738       };
97739     } catch (std::exception& e) {
97740       {
97741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97742       };
97743     } catch (Dali::DaliException e) {
97744       {
97745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97746       };
97747     } catch (...) {
97748       {
97749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97750       };
97751     }
97752   }
97753
97754 }
97755
97756
97757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97758   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97759   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
97760
97761   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97762   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
97763   {
97764     try {
97765       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97766     } catch (std::out_of_range& e) {
97767       {
97768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97769       };
97770     } catch (std::exception& e) {
97771       {
97772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97773       };
97774     } catch (Dali::DaliException e) {
97775       {
97776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97777       };
97778     } catch (...) {
97779       {
97780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97781       };
97782     }
97783   }
97784
97785 }
97786
97787
97788 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
97789   unsigned int jresult ;
97790   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97791   Dali::Toolkit::Slider arg2 ;
97792   float arg3 ;
97793   Dali::Toolkit::Slider *argp2 ;
97794   bool result;
97795
97796   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97797   argp2 = (Dali::Toolkit::Slider *)jarg2;
97798   if (!argp2) {
97799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
97800     return 0;
97801   }
97802   arg2 = *argp2;
97803   arg3 = (float)jarg3;
97804   {
97805     try {
97806       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
97807     } catch (std::out_of_range& e) {
97808       {
97809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97810       };
97811     } catch (std::exception& e) {
97812       {
97813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97814       };
97815     } catch (Dali::DaliException e) {
97816       {
97817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97818       };
97819     } catch (...) {
97820       {
97821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97822       };
97823     }
97824   }
97825
97826   jresult = result;
97827   return jresult;
97828 }
97829
97830
97831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
97832   void * jresult ;
97833   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
97834
97835   {
97836     try {
97837       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
97838     } catch (std::out_of_range& e) {
97839       {
97840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97841       };
97842     } catch (std::exception& e) {
97843       {
97844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97845       };
97846     } catch (Dali::DaliException e) {
97847       {
97848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97849       };
97850     } catch (...) {
97851       {
97852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97853       };
97854     }
97855   }
97856
97857   jresult = (void *)result;
97858   return jresult;
97859 }
97860
97861
97862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
97863   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97864
97865   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97866   {
97867     try {
97868       delete arg1;
97869     } catch (std::out_of_range& e) {
97870       {
97871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97872       };
97873     } catch (std::exception& e) {
97874       {
97875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97876       };
97877     } catch (Dali::DaliException e) {
97878       {
97879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97880       };
97881     } catch (...) {
97882       {
97883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97884       };
97885     }
97886   }
97887
97888 }
97889
97890
97891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
97892   unsigned int jresult ;
97893   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97894   bool result;
97895
97896   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97897   {
97898     try {
97899       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
97900     } catch (std::out_of_range& e) {
97901       {
97902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97903       };
97904     } catch (std::exception& e) {
97905       {
97906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97907       };
97908     } catch (Dali::DaliException e) {
97909       {
97910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97911       };
97912     } catch (...) {
97913       {
97914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97915       };
97916     }
97917   }
97918
97919   jresult = result;
97920   return jresult;
97921 }
97922
97923
97924 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
97925   unsigned long jresult ;
97926   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97927   std::size_t result;
97928
97929   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97930   {
97931     try {
97932       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
97933     } catch (std::out_of_range& e) {
97934       {
97935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97936       };
97937     } catch (std::exception& e) {
97938       {
97939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97940       };
97941     } catch (Dali::DaliException e) {
97942       {
97943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97944       };
97945     } catch (...) {
97946       {
97947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97948       };
97949     }
97950   }
97951
97952   jresult = (unsigned long)result;
97953   return jresult;
97954 }
97955
97956
97957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
97958   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97959   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
97960
97961   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97962   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
97963   {
97964     try {
97965       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
97966     } catch (std::out_of_range& e) {
97967       {
97968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97969       };
97970     } catch (std::exception& e) {
97971       {
97972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97973       };
97974     } catch (Dali::DaliException e) {
97975       {
97976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97977       };
97978     } catch (...) {
97979       {
97980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97981       };
97982     }
97983   }
97984
97985 }
97986
97987
97988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
97989   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97990   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
97991
97992   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97993   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
97994   {
97995     try {
97996       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
97997     } catch (std::out_of_range& e) {
97998       {
97999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98000       };
98001     } catch (std::exception& e) {
98002       {
98003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98004       };
98005     } catch (Dali::DaliException e) {
98006       {
98007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98008       };
98009     } catch (...) {
98010       {
98011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98012       };
98013     }
98014   }
98015
98016 }
98017
98018
98019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
98020   unsigned int jresult ;
98021   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98022   Dali::Toolkit::Slider arg2 ;
98023   int arg3 ;
98024   Dali::Toolkit::Slider *argp2 ;
98025   bool result;
98026
98027   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98028   argp2 = (Dali::Toolkit::Slider *)jarg2;
98029   if (!argp2) {
98030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98031     return 0;
98032   }
98033   arg2 = *argp2;
98034   arg3 = (int)jarg3;
98035   {
98036     try {
98037       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
98038     } catch (std::out_of_range& e) {
98039       {
98040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98041       };
98042     } catch (std::exception& e) {
98043       {
98044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98045       };
98046     } catch (Dali::DaliException e) {
98047       {
98048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98049       };
98050     } catch (...) {
98051       {
98052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98053       };
98054     }
98055   }
98056
98057   jresult = result;
98058   return jresult;
98059 }
98060
98061
98062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
98063   void * jresult ;
98064   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
98065
98066   {
98067     try {
98068       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
98069     } catch (std::out_of_range& e) {
98070       {
98071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98072       };
98073     } catch (std::exception& e) {
98074       {
98075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98076       };
98077     } catch (Dali::DaliException e) {
98078       {
98079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98080       };
98081     } catch (...) {
98082       {
98083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98084       };
98085     }
98086   }
98087
98088   jresult = (void *)result;
98089   return jresult;
98090 }
98091
98092
98093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
98094   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98095
98096   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98097   {
98098     try {
98099       delete arg1;
98100     } catch (std::out_of_range& e) {
98101       {
98102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98103       };
98104     } catch (std::exception& e) {
98105       {
98106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98107       };
98108     } catch (Dali::DaliException e) {
98109       {
98110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98111       };
98112     } catch (...) {
98113       {
98114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98115       };
98116     }
98117   }
98118
98119 }
98120
98121
98122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
98123   void * jresult ;
98124   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98125
98126   {
98127     try {
98128       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
98129     } catch (std::out_of_range& e) {
98130       {
98131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98132       };
98133     } catch (std::exception& e) {
98134       {
98135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98136       };
98137     } catch (Dali::DaliException e) {
98138       {
98139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98140       };
98141     } catch (...) {
98142       {
98143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98144       };
98145     }
98146   }
98147
98148   jresult = (void *)result;
98149   return jresult;
98150 }
98151
98152
98153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
98154   void * jresult ;
98155   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
98156   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98157
98158   arg1 = (Dali::Toolkit::Ruler *)jarg1;
98159   {
98160     try {
98161       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
98162     } catch (std::out_of_range& e) {
98163       {
98164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98165       };
98166     } catch (std::exception& e) {
98167       {
98168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98169       };
98170     } catch (Dali::DaliException e) {
98171       {
98172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98173       };
98174     } catch (...) {
98175       {
98176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98177       };
98178     }
98179   }
98180
98181   jresult = (void *)result;
98182   return jresult;
98183 }
98184
98185
98186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
98187   void * jresult ;
98188   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
98189   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98190
98191   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98192   if (!arg1) {
98193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
98194     return 0;
98195   }
98196   {
98197     try {
98198       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
98199     } catch (std::out_of_range& e) {
98200       {
98201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98202       };
98203     } catch (std::exception& e) {
98204       {
98205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98206       };
98207     } catch (Dali::DaliException e) {
98208       {
98209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98210       };
98211     } catch (...) {
98212       {
98213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98214       };
98215     }
98216   }
98217
98218   jresult = (void *)result;
98219   return jresult;
98220 }
98221
98222
98223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
98224   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98225
98226   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98227   {
98228     try {
98229       delete arg1;
98230     } catch (std::out_of_range& e) {
98231       {
98232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98233       };
98234     } catch (std::exception& e) {
98235       {
98236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98237       };
98238     } catch (Dali::DaliException e) {
98239       {
98240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98241       };
98242     } catch (...) {
98243       {
98244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98245       };
98246     }
98247   }
98248
98249 }
98250
98251
98252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
98253   void * jresult ;
98254   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98255   Dali::Toolkit::Ruler *result = 0 ;
98256
98257   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98258   {
98259     try {
98260       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
98261     } catch (std::out_of_range& e) {
98262       {
98263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98264       };
98265     } catch (std::exception& e) {
98266       {
98267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98268       };
98269     } catch (Dali::DaliException e) {
98270       {
98271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98272       };
98273     } catch (...) {
98274       {
98275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98276       };
98277     }
98278   }
98279
98280   jresult = (void *)result;
98281   return jresult;
98282 }
98283
98284
98285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
98286   void * jresult ;
98287   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98288   Dali::Toolkit::Ruler *result = 0 ;
98289
98290   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98291   {
98292     try {
98293       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
98294     } catch (std::out_of_range& e) {
98295       {
98296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98297       };
98298     } catch (std::exception& e) {
98299       {
98300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98301       };
98302     } catch (Dali::DaliException e) {
98303       {
98304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98305       };
98306     } catch (...) {
98307       {
98308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98309       };
98310     }
98311   }
98312
98313   jresult = (void *)result;
98314   return jresult;
98315 }
98316
98317
98318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
98319   void * jresult ;
98320   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98321   Dali::Toolkit::Ruler *result = 0 ;
98322
98323   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98324   {
98325     try {
98326       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
98327     } catch (std::out_of_range& e) {
98328       {
98329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98330       };
98331     } catch (std::exception& e) {
98332       {
98333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98334       };
98335     } catch (Dali::DaliException e) {
98336       {
98337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98338       };
98339     } catch (...) {
98340       {
98341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98342       };
98343     }
98344   }
98345
98346   jresult = (void *)result;
98347   return jresult;
98348 }
98349
98350
98351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
98352   void * jresult ;
98353   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98354   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
98355   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98356
98357   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98358   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
98359   if (!arg2) {
98360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
98361     return 0;
98362   }
98363   {
98364     try {
98365       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
98366     } catch (std::out_of_range& e) {
98367       {
98368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98369       };
98370     } catch (std::exception& e) {
98371       {
98372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98373       };
98374     } catch (Dali::DaliException e) {
98375       {
98376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98377       };
98378     } catch (...) {
98379       {
98380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98381       };
98382     }
98383   }
98384
98385   jresult = (void *)result;
98386   return jresult;
98387 }
98388
98389
98390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
98391   void * jresult ;
98392   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98393   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
98394   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98395
98396   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98397   arg2 = (Dali::Toolkit::Ruler *)jarg2;
98398   {
98399     try {
98400       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
98401     } catch (std::out_of_range& e) {
98402       {
98403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98404       };
98405     } catch (std::exception& e) {
98406       {
98407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98408       };
98409     } catch (Dali::DaliException e) {
98410       {
98411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98412       };
98413     } catch (...) {
98414       {
98415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98416       };
98417     }
98418   }
98419
98420   jresult = (void *)result;
98421   return jresult;
98422 }
98423
98424
98425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
98426   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98427
98428   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98429   {
98430     try {
98431       (arg1)->Reset();
98432     } catch (std::out_of_range& e) {
98433       {
98434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98435       };
98436     } catch (std::exception& e) {
98437       {
98438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98439       };
98440     } catch (Dali::DaliException e) {
98441       {
98442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98443       };
98444     } catch (...) {
98445       {
98446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98447       };
98448     }
98449   }
98450
98451 }
98452
98453
98454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
98455   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98456   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
98457
98458   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98459   arg2 = (Dali::Toolkit::Ruler *)jarg2;
98460   {
98461     try {
98462       (arg1)->Reset(arg2);
98463     } catch (std::out_of_range& e) {
98464       {
98465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98466       };
98467     } catch (std::exception& e) {
98468       {
98469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98470       };
98471     } catch (Dali::DaliException e) {
98472       {
98473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98474       };
98475     } catch (...) {
98476       {
98477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98478       };
98479     }
98480   }
98481
98482 }
98483
98484
98485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
98486   void * jresult ;
98487   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98488   Dali::Toolkit::Ruler *result = 0 ;
98489
98490   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98491   {
98492     try {
98493       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
98494     } catch (std::out_of_range& e) {
98495       {
98496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98497       };
98498     } catch (std::exception& e) {
98499       {
98500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98501       };
98502     } catch (Dali::DaliException e) {
98503       {
98504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98505       };
98506     } catch (...) {
98507       {
98508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98509       };
98510     }
98511   }
98512
98513   jresult = (void *)result;
98514   return jresult;
98515 }
98516
98517
98518 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
98519   float jresult ;
98520   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98521   float arg2 ;
98522   float arg3 ;
98523   float result;
98524
98525   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98526   arg2 = (float)jarg2;
98527   arg3 = (float)jarg3;
98528   {
98529     try {
98530       result = (float)(*arg1)->Snap(arg2,arg3);
98531     } catch (std::out_of_range& e) {
98532       {
98533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98534       };
98535     } catch (std::exception& e) {
98536       {
98537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98538       };
98539     } catch (Dali::DaliException e) {
98540       {
98541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98542       };
98543     } catch (...) {
98544       {
98545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98546       };
98547     }
98548   }
98549
98550   jresult = result;
98551   return jresult;
98552 }
98553
98554
98555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
98556   float jresult ;
98557   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98558   float arg2 ;
98559   float result;
98560
98561   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98562   arg2 = (float)jarg2;
98563   {
98564     try {
98565       result = (float)(*arg1)->Snap(arg2);
98566     } catch (std::out_of_range& e) {
98567       {
98568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98569       };
98570     } catch (std::exception& e) {
98571       {
98572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98573       };
98574     } catch (Dali::DaliException e) {
98575       {
98576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98577       };
98578     } catch (...) {
98579       {
98580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98581       };
98582     }
98583   }
98584
98585   jresult = result;
98586   return jresult;
98587 }
98588
98589
98590 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
98591   float jresult ;
98592   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98593   unsigned int arg2 ;
98594   unsigned int *arg3 = 0 ;
98595   bool arg4 ;
98596   float result;
98597
98598   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98599   arg2 = (unsigned int)jarg2;
98600   arg3 = (unsigned int *)jarg3;
98601   arg4 = jarg4 ? true : false;
98602   {
98603     try {
98604       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
98605     } catch (std::out_of_range& e) {
98606       {
98607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98608       };
98609     } catch (std::exception& e) {
98610       {
98611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98612       };
98613     } catch (Dali::DaliException e) {
98614       {
98615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98616       };
98617     } catch (...) {
98618       {
98619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98620       };
98621     }
98622   }
98623
98624   jresult = result;
98625   return jresult;
98626 }
98627
98628
98629 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
98630   unsigned int jresult ;
98631   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98632   float arg2 ;
98633   bool arg3 ;
98634   unsigned int result;
98635
98636   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98637   arg2 = (float)jarg2;
98638   arg3 = jarg3 ? true : false;
98639   {
98640     try {
98641       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
98642     } catch (std::out_of_range& e) {
98643       {
98644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98645       };
98646     } catch (std::exception& e) {
98647       {
98648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98649       };
98650     } catch (Dali::DaliException e) {
98651       {
98652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98653       };
98654     } catch (...) {
98655       {
98656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98657       };
98658     }
98659   }
98660
98661   jresult = result;
98662   return jresult;
98663 }
98664
98665
98666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
98667   unsigned int jresult ;
98668   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98669   unsigned int result;
98670
98671   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98672   {
98673     try {
98674       result = (unsigned int)(*arg1)->GetTotalPages();
98675     } catch (std::out_of_range& e) {
98676       {
98677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98678       };
98679     } catch (std::exception& e) {
98680       {
98681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98682       };
98683     } catch (Dali::DaliException e) {
98684       {
98685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98686       };
98687     } catch (...) {
98688       {
98689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98690       };
98691     }
98692   }
98693
98694   jresult = result;
98695   return jresult;
98696 }
98697
98698
98699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
98700   int jresult ;
98701   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98702   Dali::Toolkit::Ruler::RulerType result;
98703
98704   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98705   {
98706     try {
98707       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
98708     } catch (std::out_of_range& e) {
98709       {
98710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98711       };
98712     } catch (std::exception& e) {
98713       {
98714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98715       };
98716     } catch (Dali::DaliException e) {
98717       {
98718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98719       };
98720     } catch (...) {
98721       {
98722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98723       };
98724     }
98725   }
98726
98727   jresult = (int)result;
98728   return jresult;
98729 }
98730
98731
98732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
98733   unsigned int jresult ;
98734   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98735   bool result;
98736
98737   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98738   {
98739     try {
98740       result = (bool)(*arg1)->IsEnabled();
98741     } catch (std::out_of_range& e) {
98742       {
98743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98744       };
98745     } catch (std::exception& e) {
98746       {
98747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98748       };
98749     } catch (Dali::DaliException e) {
98750       {
98751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98752       };
98753     } catch (...) {
98754       {
98755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98756       };
98757     }
98758   }
98759
98760   jresult = result;
98761   return jresult;
98762 }
98763
98764
98765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
98766   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98767
98768   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98769   {
98770     try {
98771       (*arg1)->Enable();
98772     } catch (std::out_of_range& e) {
98773       {
98774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98775       };
98776     } catch (std::exception& e) {
98777       {
98778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98779       };
98780     } catch (Dali::DaliException e) {
98781       {
98782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98783       };
98784     } catch (...) {
98785       {
98786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98787       };
98788     }
98789   }
98790
98791 }
98792
98793
98794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
98795   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98796
98797   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98798   {
98799     try {
98800       (*arg1)->Disable();
98801     } catch (std::out_of_range& e) {
98802       {
98803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98804       };
98805     } catch (std::exception& e) {
98806       {
98807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98808       };
98809     } catch (Dali::DaliException e) {
98810       {
98811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98812       };
98813     } catch (...) {
98814       {
98815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98816       };
98817     }
98818   }
98819
98820 }
98821
98822
98823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
98824   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98825   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
98826   Dali::Toolkit::RulerDomain *argp2 ;
98827
98828   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98829   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
98830   if (!argp2) {
98831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
98832     return ;
98833   }
98834   arg2 = *argp2;
98835   {
98836     try {
98837       (*arg1)->SetDomain(arg2);
98838     } catch (std::out_of_range& e) {
98839       {
98840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98841       };
98842     } catch (std::exception& e) {
98843       {
98844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98845       };
98846     } catch (Dali::DaliException e) {
98847       {
98848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98849       };
98850     } catch (...) {
98851       {
98852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98853       };
98854     }
98855   }
98856
98857 }
98858
98859
98860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
98861   void * jresult ;
98862   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98863   Dali::Toolkit::RulerDomain *result = 0 ;
98864
98865   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98866   {
98867     try {
98868       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
98869     } catch (std::out_of_range& e) {
98870       {
98871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98872       };
98873     } catch (std::exception& e) {
98874       {
98875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98876       };
98877     } catch (Dali::DaliException e) {
98878       {
98879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98880       };
98881     } catch (...) {
98882       {
98883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98884       };
98885     }
98886   }
98887
98888   jresult = (void *)result;
98889   return jresult;
98890 }
98891
98892
98893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
98894   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98895
98896   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98897   {
98898     try {
98899       (*arg1)->DisableDomain();
98900     } catch (std::out_of_range& e) {
98901       {
98902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98903       };
98904     } catch (std::exception& e) {
98905       {
98906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98907       };
98908     } catch (Dali::DaliException e) {
98909       {
98910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98911       };
98912     } catch (...) {
98913       {
98914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98915       };
98916     }
98917   }
98918
98919 }
98920
98921
98922 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
98923   float jresult ;
98924   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98925   float arg2 ;
98926   float arg3 ;
98927   float arg4 ;
98928   float result;
98929
98930   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98931   arg2 = (float)jarg2;
98932   arg3 = (float)jarg3;
98933   arg4 = (float)jarg4;
98934   {
98935     try {
98936       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
98937     } catch (std::out_of_range& e) {
98938       {
98939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98940       };
98941     } catch (std::exception& e) {
98942       {
98943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98944       };
98945     } catch (Dali::DaliException e) {
98946       {
98947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98948       };
98949     } catch (...) {
98950       {
98951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98952       };
98953     }
98954   }
98955
98956   jresult = result;
98957   return jresult;
98958 }
98959
98960
98961 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
98962   float jresult ;
98963   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98964   float arg2 ;
98965   float arg3 ;
98966   float result;
98967
98968   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98969   arg2 = (float)jarg2;
98970   arg3 = (float)jarg3;
98971   {
98972     try {
98973       result = (float)(*arg1)->Clamp(arg2,arg3);
98974     } catch (std::out_of_range& e) {
98975       {
98976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98977       };
98978     } catch (std::exception& e) {
98979       {
98980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98981       };
98982     } catch (Dali::DaliException e) {
98983       {
98984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98985       };
98986     } catch (...) {
98987       {
98988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98989       };
98990     }
98991   }
98992
98993   jresult = result;
98994   return jresult;
98995 }
98996
98997
98998 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
98999   float jresult ;
99000   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99001   float arg2 ;
99002   float result;
99003
99004   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99005   arg2 = (float)jarg2;
99006   {
99007     try {
99008       result = (float)(*arg1)->Clamp(arg2);
99009     } catch (std::out_of_range& e) {
99010       {
99011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99012       };
99013     } catch (std::exception& e) {
99014       {
99015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99016       };
99017     } catch (Dali::DaliException e) {
99018       {
99019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99020       };
99021     } catch (...) {
99022       {
99023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99024       };
99025     }
99026   }
99027
99028   jresult = result;
99029   return jresult;
99030 }
99031
99032
99033 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
99034   float jresult ;
99035   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99036   float arg2 ;
99037   float arg3 ;
99038   float arg4 ;
99039   Dali::Toolkit::ClampState *arg5 = 0 ;
99040   float result;
99041
99042   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99043   arg2 = (float)jarg2;
99044   arg3 = (float)jarg3;
99045   arg4 = (float)jarg4;
99046   arg5 = (Dali::Toolkit::ClampState *)jarg5;
99047   if (!arg5) {
99048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
99049     return 0;
99050   }
99051   {
99052     try {
99053       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
99054     } catch (std::out_of_range& e) {
99055       {
99056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99057       };
99058     } catch (std::exception& e) {
99059       {
99060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99061       };
99062     } catch (Dali::DaliException e) {
99063       {
99064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99065       };
99066     } catch (...) {
99067       {
99068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99069       };
99070     }
99071   }
99072
99073   jresult = result;
99074   return jresult;
99075 }
99076
99077
99078 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
99079   float jresult ;
99080   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99081   float arg2 ;
99082   float arg3 ;
99083   float arg4 ;
99084   float arg5 ;
99085   float result;
99086
99087   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99088   arg2 = (float)jarg2;
99089   arg3 = (float)jarg3;
99090   arg4 = (float)jarg4;
99091   arg5 = (float)jarg5;
99092   {
99093     try {
99094       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
99095     } catch (std::out_of_range& e) {
99096       {
99097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99098       };
99099     } catch (std::exception& e) {
99100       {
99101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99102       };
99103     } catch (Dali::DaliException e) {
99104       {
99105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99106       };
99107     } catch (...) {
99108       {
99109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99110       };
99111     }
99112   }
99113
99114   jresult = result;
99115   return jresult;
99116 }
99117
99118
99119 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
99120   float jresult ;
99121   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99122   float arg2 ;
99123   float arg3 ;
99124   float arg4 ;
99125   float result;
99126
99127   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99128   arg2 = (float)jarg2;
99129   arg3 = (float)jarg3;
99130   arg4 = (float)jarg4;
99131   {
99132     try {
99133       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
99134     } catch (std::out_of_range& e) {
99135       {
99136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99137       };
99138     } catch (std::exception& e) {
99139       {
99140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99141       };
99142     } catch (Dali::DaliException e) {
99143       {
99144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99145       };
99146     } catch (...) {
99147       {
99148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99149       };
99150     }
99151   }
99152
99153   jresult = result;
99154   return jresult;
99155 }
99156
99157
99158 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
99159   float jresult ;
99160   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99161   float arg2 ;
99162   float arg3 ;
99163   float result;
99164
99165   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99166   arg2 = (float)jarg2;
99167   arg3 = (float)jarg3;
99168   {
99169     try {
99170       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
99171     } catch (std::out_of_range& e) {
99172       {
99173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99174       };
99175     } catch (std::exception& e) {
99176       {
99177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99178       };
99179     } catch (Dali::DaliException e) {
99180       {
99181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99182       };
99183     } catch (...) {
99184       {
99185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99186       };
99187     }
99188   }
99189
99190   jresult = result;
99191   return jresult;
99192 }
99193
99194
99195 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
99196   float jresult ;
99197   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99198   float arg2 ;
99199   float result;
99200
99201   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99202   arg2 = (float)jarg2;
99203   {
99204     try {
99205       result = (float)(*arg1)->SnapAndClamp(arg2);
99206     } catch (std::out_of_range& e) {
99207       {
99208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99209       };
99210     } catch (std::exception& e) {
99211       {
99212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99213       };
99214     } catch (Dali::DaliException e) {
99215       {
99216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99217       };
99218     } catch (...) {
99219       {
99220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99221       };
99222     }
99223   }
99224
99225   jresult = result;
99226   return jresult;
99227 }
99228
99229
99230 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
99231   float jresult ;
99232   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99233   float arg2 ;
99234   float arg3 ;
99235   float arg4 ;
99236   float arg5 ;
99237   Dali::Toolkit::ClampState *arg6 = 0 ;
99238   float result;
99239
99240   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99241   arg2 = (float)jarg2;
99242   arg3 = (float)jarg3;
99243   arg4 = (float)jarg4;
99244   arg5 = (float)jarg5;
99245   arg6 = (Dali::Toolkit::ClampState *)jarg6;
99246   if (!arg6) {
99247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
99248     return 0;
99249   }
99250   {
99251     try {
99252       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
99253     } catch (std::out_of_range& e) {
99254       {
99255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99256       };
99257     } catch (std::exception& e) {
99258       {
99259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99260       };
99261     } catch (Dali::DaliException e) {
99262       {
99263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99264       };
99265     } catch (...) {
99266       {
99267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99268       };
99269     }
99270   }
99271
99272   jresult = result;
99273   return jresult;
99274 }
99275
99276
99277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
99278   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99279
99280   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99281   {
99282     try {
99283       (*arg1)->Reference();
99284     } catch (std::out_of_range& e) {
99285       {
99286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99287       };
99288     } catch (std::exception& e) {
99289       {
99290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99291       };
99292     } catch (Dali::DaliException e) {
99293       {
99294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99295       };
99296     } catch (...) {
99297       {
99298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99299       };
99300     }
99301   }
99302
99303 }
99304
99305
99306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
99307   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99308
99309   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99310   {
99311     try {
99312       (*arg1)->Unreference();
99313     } catch (std::out_of_range& e) {
99314       {
99315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99316       };
99317     } catch (std::exception& e) {
99318       {
99319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99320       };
99321     } catch (Dali::DaliException e) {
99322       {
99323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99324       };
99325     } catch (...) {
99326       {
99327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99328       };
99329     }
99330   }
99331
99332 }
99333
99334
99335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
99336   int jresult ;
99337   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99338   int result;
99339
99340   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99341   {
99342     try {
99343       result = (int)(*arg1)->ReferenceCount();
99344     } catch (std::out_of_range& e) {
99345       {
99346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99347       };
99348     } catch (std::exception& e) {
99349       {
99350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99351       };
99352     } catch (Dali::DaliException e) {
99353       {
99354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99355       };
99356     } catch (...) {
99357       {
99358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99359       };
99360     }
99361   }
99362
99363   jresult = result;
99364   return jresult;
99365 }
99366
99367
99368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
99369   unsigned int jresult ;
99370   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99371   bool result;
99372
99373   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99374   {
99375     try {
99376       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
99377     } catch (std::out_of_range& e) {
99378       {
99379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99380       };
99381     } catch (std::exception& e) {
99382       {
99383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99384       };
99385     } catch (Dali::DaliException e) {
99386       {
99387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99388       };
99389     } catch (...) {
99390       {
99391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99392       };
99393     }
99394   }
99395
99396   jresult = result;
99397   return jresult;
99398 }
99399
99400
99401 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
99402   unsigned long jresult ;
99403   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99404   std::size_t result;
99405
99406   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99407   {
99408     try {
99409       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
99410     } catch (std::out_of_range& e) {
99411       {
99412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99413       };
99414     } catch (std::exception& e) {
99415       {
99416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99417       };
99418     } catch (Dali::DaliException e) {
99419       {
99420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99421       };
99422     } catch (...) {
99423       {
99424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99425       };
99426     }
99427   }
99428
99429   jresult = (unsigned long)result;
99430   return jresult;
99431 }
99432
99433
99434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
99435   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99436   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
99437
99438   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99439   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
99440   {
99441     try {
99442       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
99443     } catch (std::out_of_range& e) {
99444       {
99445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99446       };
99447     } catch (std::exception& e) {
99448       {
99449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99450       };
99451     } catch (Dali::DaliException e) {
99452       {
99453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99454       };
99455     } catch (...) {
99456       {
99457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99458       };
99459     }
99460   }
99461
99462 }
99463
99464
99465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
99466   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99467   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
99468
99469   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99470   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
99471   {
99472     try {
99473       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
99474     } catch (std::out_of_range& e) {
99475       {
99476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99477       };
99478     } catch (std::exception& e) {
99479       {
99480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99481       };
99482     } catch (Dali::DaliException e) {
99483       {
99484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99485       };
99486     } catch (...) {
99487       {
99488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99489       };
99490     }
99491   }
99492
99493 }
99494
99495
99496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
99497   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99498   Dali::Toolkit::Control arg2 ;
99499   Dali::Toolkit::Control *argp2 ;
99500
99501   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99502   argp2 = (Dali::Toolkit::Control *)jarg2;
99503   if (!argp2) {
99504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
99505     return ;
99506   }
99507   arg2 = *argp2;
99508   {
99509     try {
99510       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
99511     } catch (std::out_of_range& e) {
99512       {
99513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99514       };
99515     } catch (std::exception& e) {
99516       {
99517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99518       };
99519     } catch (Dali::DaliException e) {
99520       {
99521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99522       };
99523     } catch (...) {
99524       {
99525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99526       };
99527     }
99528   }
99529
99530 }
99531
99532
99533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
99534   void * jresult ;
99535   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
99536
99537   {
99538     try {
99539       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
99540     } catch (std::out_of_range& e) {
99541       {
99542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99543       };
99544     } catch (std::exception& e) {
99545       {
99546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99547       };
99548     } catch (Dali::DaliException e) {
99549       {
99550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99551       };
99552     } catch (...) {
99553       {
99554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99555       };
99556     }
99557   }
99558
99559   jresult = (void *)result;
99560   return jresult;
99561 }
99562
99563
99564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
99565   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99566
99567   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99568   {
99569     try {
99570       delete arg1;
99571     } catch (std::out_of_range& e) {
99572       {
99573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99574       };
99575     } catch (std::exception& e) {
99576       {
99577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99578       };
99579     } catch (Dali::DaliException e) {
99580       {
99581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99582       };
99583     } catch (...) {
99584       {
99585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99586       };
99587     }
99588   }
99589
99590 }
99591
99592 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
99593   Dali::RefObject *result = NULL;
99594
99595   if (arg1)
99596   {
99597     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
99598   }
99599   return result;
99600 }
99601
99602 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
99603     return (Dali::RefObject *)jarg1;
99604 }
99605
99606 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
99607     return (Dali::SignalObserver *)jarg1;
99608 }
99609
99610 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
99611     return (Dali::ConnectionTrackerInterface *)jarg1;
99612 }
99613
99614 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
99615     return (Dali::BaseHandle *)jarg1;
99616 }
99617
99618 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
99619     return (Dali::BaseHandle *)jarg1;
99620 }
99621
99622 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
99623     return (Dali::BaseHandle *)jarg1;
99624 }
99625
99626 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
99627     return (Dali::BaseHandle *)jarg1;
99628 }
99629
99630 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
99631     return (Dali::BaseHandle *)jarg1;
99632 }
99633
99634 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
99635     return (Dali::BaseHandle *)jarg1;
99636 }
99637
99638 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
99639     return (Dali::BaseHandle *)jarg1;
99640 }
99641
99642 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
99643     return (Dali::BaseHandle *)jarg1;
99644 }
99645
99646 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
99647     return (Dali::BaseHandle *)jarg1;
99648 }
99649
99650 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
99651     return (Dali::BaseHandle *)jarg1;
99652 }
99653
99654 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
99655     return (Dali::BaseHandle *)jarg1;
99656 }
99657
99658 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
99659     return (Dali::BaseHandle *)jarg1;
99660 }
99661
99662 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
99663     return (Dali::BaseHandle *)jarg1;
99664 }
99665
99666 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
99667     return (Dali::Handle *)jarg1;
99668 }
99669
99670 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
99671     return (Dali::Handle *)jarg1;
99672 }
99673
99674 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
99675     return (Dali::BaseHandle *)jarg1;
99676 }
99677
99678 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
99679     return (Dali::BaseHandle *)jarg1;
99680 }
99681
99682 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
99683     return (Dali::Handle *)jarg1;
99684 }
99685
99686 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
99687     return (Dali::BaseHandle *)jarg1;
99688 }
99689
99690 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
99691     return (Dali::Handle *)jarg1;
99692 }
99693
99694 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
99695     return (Dali::GestureDetector *)jarg1;
99696 }
99697
99698 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
99699     return (Dali::Gesture *)jarg1;
99700 }
99701
99702 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
99703     return (Dali::Handle *)jarg1;
99704 }
99705
99706 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
99707     return (Dali::Actor *)jarg1;
99708 }
99709
99710 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
99711     return (Dali::BaseHandle *)jarg1;
99712 }
99713
99714 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
99715     return (Dali::RefObject *)jarg1;
99716 }
99717
99718 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
99719     return (Dali::Actor *)jarg1;
99720 }
99721
99722 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
99723     return (Dali::GestureDetector *)jarg1;
99724 }
99725
99726 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
99727     return (Dali::Gesture *)jarg1;
99728 }
99729
99730 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
99731     return (Dali::GestureDetector *)jarg1;
99732 }
99733
99734 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
99735     return (Dali::Gesture *)jarg1;
99736 }
99737
99738 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
99739     return (Dali::GestureDetector *)jarg1;
99740 }
99741
99742 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
99743     return (Dali::Gesture *)jarg1;
99744 }
99745
99746 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
99747     return (Dali::BaseHandle *)jarg1;
99748 }
99749
99750 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
99751     return (Dali::Handle *)jarg1;
99752 }
99753
99754 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
99755     return (Dali::Handle *)jarg1;
99756 }
99757
99758 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
99759     return (Dali::Handle *)jarg1;
99760 }
99761
99762 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
99763     return (Dali::Image *)jarg1;
99764 }
99765
99766 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
99767     return (Dali::Image *)jarg1;
99768 }
99769
99770 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
99771     return (Dali::Image *)jarg1;
99772 }
99773
99774 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
99775     return (Dali::RefObject *)jarg1;
99776 }
99777
99778 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
99779     return (Dali::Image *)jarg1;
99780 }
99781
99782 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
99783     return (Dali::Image *)jarg1;
99784 }
99785
99786 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
99787     return (Dali::ResourceImage *)jarg1;
99788 }
99789
99790 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
99791     return (Dali::Actor *)jarg1;
99792 }
99793
99794 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
99795     return (Dali::BaseHandle *)jarg1;
99796 }
99797
99798 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
99799     return (Dali::BaseHandle *)jarg1;
99800 }
99801
99802 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
99803     return (Dali::BaseHandle *)jarg1;
99804 }
99805
99806 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
99807     return (Dali::CustomActorImpl *)jarg1;
99808 }
99809
99810 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
99811     return (Dali::CustomActor *)jarg1;
99812 }
99813
99814 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
99815     return (Dali::BaseHandle *)jarg1;
99816 }
99817
99818 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
99819     return (Dali::Toolkit::Control *)jarg1;
99820 }
99821
99822 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
99823     return (Dali::Toolkit::Control *)jarg1;
99824 }
99825
99826 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
99827     return (Dali::Toolkit::Button *)jarg1;
99828 }
99829
99830 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
99831     return (Dali::Toolkit::Button *)jarg1;
99832 }
99833
99834 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
99835     return (Dali::Toolkit::Button *)jarg1;
99836 }
99837
99838 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
99839     return (Dali::Toolkit::Control *)jarg1;
99840 }
99841
99842 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
99843     return (Dali::Toolkit::Control *)jarg1;
99844 }
99845
99846 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
99847     return (Dali::Toolkit::Control *)jarg1;
99848 }
99849
99850 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
99851     return (Dali::Toolkit::Control *)jarg1;
99852 }
99853
99854 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
99855     return (Dali::Toolkit::Control *)jarg1;
99856 }
99857
99858 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
99859     return (Dali::RefObject *)jarg1;
99860 }
99861
99862 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
99863     return (Dali::Toolkit::Scrollable *)jarg1;
99864 }
99865
99866 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
99867     return (Dali::BaseHandle *)jarg1;
99868 }
99869
99870 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
99871     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
99872 }
99873
99874 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
99875     return (Dali::RefObject *)jarg1;
99876 }
99877
99878 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
99879     return (Dali::Toolkit::Ruler *)jarg1;
99880 }
99881
99882 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
99883     return (Dali::Toolkit::Ruler *)jarg1;
99884 }
99885
99886 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
99887     return (Dali::Toolkit::Scrollable *)jarg1;
99888 }
99889
99890 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
99891     return (Dali::Toolkit::Control *)jarg1;
99892 }
99893
99894
99895 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
99896     return (Dali::Toolkit::Control *)jarg1;
99897 }
99898
99899 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
99900     return (Dali::BaseHandle *)jarg1;
99901 }
99902
99903 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
99904     return (Dali::BaseHandle *)jarg1;
99905 }
99906
99907 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
99908     return (Dali::Toolkit::Control *)jarg1;
99909 }
99910
99911 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
99912     return (Dali::Toolkit::Control *)jarg1;
99913 }
99914
99915 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
99916     return (Dali::Toolkit::Control *)jarg1;
99917 }
99918
99919 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
99920     return (Dali::Toolkit::Control *)jarg1;
99921 }
99922
99923 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
99924     return (Dali::Toolkit::Control *)jarg1;
99925 }
99926
99927 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
99928     return (Dali::Toolkit::Control *)jarg1;
99929 }
99930
99931 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
99932     return (Dali::Toolkit::PageTurnView *)jarg1;
99933 }
99934
99935 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
99936     return (Dali::Toolkit::PageTurnView *)jarg1;
99937 }
99938
99939 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
99940     return (Dali::Toolkit::Button *)jarg1;
99941 }
99942
99943 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
99944     return (Dali::BaseHandle *)jarg1;
99945 }
99946
99947 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
99948     return (Dali::BaseHandle *)jarg1;
99949 }
99950
99951 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
99952     return (Dali::BaseHandle *)jarg1;
99953 }
99954
99955 /*
99956  * Widget binding
99957  */
99958 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
99959     return (Dali::BaseHandle *)jarg1;
99960 }
99961
99962 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
99963     return (Dali::BaseObject *)jarg1;
99964 }
99965
99966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
99967   void * jresult ;
99968   Dali::Widget result;
99969
99970   {
99971     try {
99972       result = Dali::Widget::New();
99973     } catch (std::out_of_range& e) {
99974       {
99975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99976       };
99977     } catch (std::exception& e) {
99978       {
99979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99980       };
99981     } catch (...) {
99982       {
99983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99984       };
99985     }
99986   }
99987   jresult = new Dali::Widget((const Dali::Widget &)result);
99988   return jresult;
99989 }
99990
99991
99992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
99993   void * jresult ;
99994   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
99995   Dali::Widget result;
99996
99997   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99998
99999   if (!arg1) {
100000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
100001     return 0;
100002   }
100003   {
100004     try {
100005       jresult = new Dali::Widget(arg1);
100006     } catch (std::out_of_range& e) {
100007       {
100008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100009       };
100010     } catch (std::exception& e) {
100011       {
100012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100013       };
100014     } catch (...) {
100015       {
100016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100017       };
100018     }
100019   }
100020   return jresult;
100021 }
100022
100023
100024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
100025   void * jresult ;
100026   Dali::Widget *result = 0 ;
100027
100028   {
100029     try {
100030       result = (Dali::Widget *)new Dali::Widget();
100031     } catch (std::out_of_range& e) {
100032       {
100033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100034       };
100035     } catch (std::exception& e) {
100036       {
100037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100038       };
100039     } catch (...) {
100040       {
100041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100042       };
100043     }
100044   }
100045   jresult = (void *)result;
100046   return jresult;
100047 }
100048
100049
100050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
100051   void * jresult ;
100052   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
100053   Dali::Widget *arg2 = 0 ;
100054   Dali::Widget *result = 0 ;
100055
100056   arg1 = (Dali::Widget *)jarg1;
100057   arg2 = (Dali::Widget *)jarg2;
100058   if (!arg2) {
100059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
100060     return 0;
100061   }
100062   {
100063     try {
100064       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
100065     } catch (std::out_of_range& e) {
100066       {
100067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100068       };
100069     } catch (std::exception& e) {
100070       {
100071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100072       };
100073     } catch (...) {
100074       {
100075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100076       };
100077     }
100078   }
100079   jresult = (void *)result;
100080   return jresult;
100081 }
100082
100083
100084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
100085   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
100086
100087   arg1 = (Dali::Widget *)jarg1;
100088   {
100089     try {
100090       delete arg1;
100091     } catch (std::out_of_range& e) {
100092       {
100093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100094       };
100095     } catch (std::exception& e) {
100096       {
100097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100098       };
100099     } catch (...) {
100100       {
100101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100102       };
100103     }
100104   }
100105 }
100106
100107
100108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
100109   void * jresult ;
100110   SwigDirector_WidgetImpl* result;
100111   {
100112     try {
100113       result = new SwigDirector_WidgetImpl();
100114     } catch (std::out_of_range& e) {
100115       {
100116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100117       };
100118     } catch (std::exception& e) {
100119       {
100120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100121       };
100122     } catch (...) {
100123       {
100124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100125       };
100126     }
100127   }
100128   jresult = result;
100129   return jresult;
100130 }
100131
100132
100133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
100134   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100135   std::string *arg2 = 0 ;
100136   Dali::Window arg3 ;
100137   Dali::Window *argp3 ;
100138
100139   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100140   if (!jarg2) {
100141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100142     return ;
100143   }
100144   std::string arg2_str(jarg2);
100145   arg2 = &arg2_str;
100146   argp3 = (Dali::Window *)jarg3;
100147   if (!argp3) {
100148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100149     return ;
100150   }
100151   arg3 = *argp3;
100152   {
100153     try {
100154       (arg1)->OnCreate((std::string const &)*arg2,arg3);
100155     } catch (std::out_of_range& e) {
100156       {
100157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100158       };
100159     } catch (std::exception& e) {
100160       {
100161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100162       };
100163     } catch (...) {
100164       {
100165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100166       };
100167     }
100168   }
100169 }
100170
100171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
100172   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100173   std::string *arg2 = 0 ;
100174   Dali::Window arg3 ;
100175   Dali::Window *argp3 ;
100176
100177   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100178   if (!jarg2) {
100179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100180     return ;
100181   }
100182   std::string arg2_str(jarg2);
100183   arg2 = &arg2_str;
100184   argp3 = (Dali::Window *)jarg3;
100185   if (!argp3) {
100186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100187     return ;
100188   }
100189   arg3 = *argp3;
100190   {
100191     try {
100192       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
100193     } catch (std::out_of_range& e) {
100194       {
100195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100196       };
100197     } catch (std::exception& e) {
100198       {
100199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100200       };
100201     } catch (...) {
100202       {
100203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100204       };
100205     }
100206   }
100207 }
100208
100209
100210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
100211   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100212   std::string *arg2 = 0 ;
100213   Dali::Widget::Termination arg3 ;
100214
100215   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100216   if (!jarg2) {
100217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100218     return ;
100219   }
100220   std::string arg2_str(jarg2);
100221   arg2 = &arg2_str;
100222   arg3 = (Dali::Widget::Termination)jarg3;
100223   {
100224     try {
100225       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
100226     } catch (std::out_of_range& e) {
100227       {
100228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100229       };
100230     } catch (std::exception& e) {
100231       {
100232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100233       };
100234     } catch (...) {
100235       {
100236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100237       };
100238     }
100239   }
100240 }
100241
100242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
100243   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100244   std::string *arg2 = 0 ;
100245   Dali::Widget::Termination arg3 ;
100246
100247   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100248   if (!jarg2) {
100249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100250     return ;
100251   }
100252   std::string arg2_str(jarg2);
100253   arg2 = &arg2_str;
100254   arg3 = (Dali::Widget::Termination)jarg3;
100255   {
100256     try {
100257       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
100258     } catch (std::out_of_range& e) {
100259       {
100260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100261       };
100262     } catch (std::exception& e) {
100263       {
100264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100265       };
100266     } catch (...) {
100267       {
100268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100269       };
100270     }
100271   }
100272 }
100273
100274
100275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
100276   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100277
100278   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100279   {
100280     try {
100281       (arg1)->OnPause();
100282     } catch (std::out_of_range& e) {
100283       {
100284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100285       };
100286     } catch (std::exception& e) {
100287       {
100288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100289       };
100290     } catch (...) {
100291       {
100292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100293       };
100294     }
100295   }
100296 }
100297
100298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
100299   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100300
100301   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100302   {
100303     try {
100304       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
100305     } catch (std::out_of_range& e) {
100306       {
100307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100308       };
100309     } catch (std::exception& e) {
100310       {
100311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100312       };
100313     } catch (...) {
100314       {
100315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100316       };
100317     }
100318   }
100319 }
100320
100321
100322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
100323   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100324
100325   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100326   {
100327     try {
100328       (arg1)->OnResume();
100329     } catch (std::out_of_range& e) {
100330       {
100331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100332       };
100333     } catch (std::exception& e) {
100334       {
100335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100336       };
100337     } catch (...) {
100338       {
100339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100340       };
100341     }
100342   }
100343 }
100344
100345
100346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
100347   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100348
100349   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100350   {
100351     try {
100352       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
100353     } catch (std::out_of_range& e) {
100354       {
100355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100356       };
100357     } catch (std::exception& e) {
100358       {
100359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100360       };
100361     } catch (...) {
100362       {
100363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100364       };
100365     }
100366   }
100367 }
100368
100369
100370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
100371   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100372   Dali::Window arg2 ;
100373   Dali::Window *argp2 ;
100374
100375   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100376   argp2 = (Dali::Window *)jarg2;
100377   if (!argp2) {
100378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100379     return ;
100380   }
100381   arg2 = *argp2;
100382   {
100383     try {
100384       (arg1)->OnResize(arg2);
100385     } catch (std::out_of_range& e) {
100386       {
100387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100388       };
100389     } catch (std::exception& e) {
100390       {
100391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100392       };
100393     } catch (...) {
100394       {
100395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100396       };
100397     }
100398   }
100399 }
100400
100401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
100402   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100403   Dali::Window arg2 ;
100404   Dali::Window *argp2 ;
100405
100406   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100407   argp2 = (Dali::Window *)jarg2;
100408   if (!argp2) {
100409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100410     return ;
100411   }
100412   arg2 = *argp2;
100413   {
100414     try {
100415       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
100416     } catch (std::out_of_range& e) {
100417       {
100418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100419       };
100420     } catch (std::exception& e) {
100421       {
100422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100423       };
100424     } catch (...) {
100425       {
100426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100427       };
100428     }
100429   }
100430 }
100431
100432
100433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
100434   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100435   std::string *arg2 = 0 ;
100436   int arg3 ;
100437
100438   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100439   if (!jarg2) {
100440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100441     return ;
100442   }
100443   std::string arg2_str(jarg2);
100444   arg2 = &arg2_str;
100445   arg3 = (int)jarg3;
100446   {
100447     try {
100448       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
100449     } catch (std::out_of_range& e) {
100450       {
100451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100452       };
100453     } catch (std::exception& e) {
100454       {
100455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100456       };
100457     } catch (...) {
100458       {
100459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100460       };
100461     }
100462   }
100463 }
100464
100465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
100466   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100467   std::string *arg2 = 0 ;
100468   int arg3 ;
100469
100470   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100471   if (!jarg2) {
100472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100473     return ;
100474   }
100475   std::string arg2_str(jarg2);
100476   arg2 = &arg2_str;
100477   arg3 = (int)jarg3;
100478   {
100479     try {
100480       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
100481     } catch (std::out_of_range& e) {
100482       {
100483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100484       };
100485     } catch (std::exception& e) {
100486       {
100487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100488       };
100489     } catch (...) {
100490       {
100491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100492       };
100493     }
100494   }
100495 }
100496
100497
100498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
100499   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100500   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100501   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100502
100503   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100504   arg2 = (Dali::SlotObserver *)jarg2;
100505   arg3 = (Dali::CallbackBase *)jarg3;
100506   {
100507     try {
100508       (arg1)->SignalConnected(arg2,arg3);
100509     } catch (std::out_of_range& e) {
100510       {
100511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100512       };
100513     } catch (std::exception& e) {
100514       {
100515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100516       };
100517     } catch (...) {
100518       {
100519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100520       };
100521     }
100522   }
100523 }
100524
100525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
100526   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100527   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100528   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100529
100530   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100531   arg2 = (Dali::SlotObserver *)jarg2;
100532   arg3 = (Dali::CallbackBase *)jarg3;
100533   {
100534     try {
100535       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
100536     } catch (std::out_of_range& e) {
100537       {
100538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100539       };
100540     } catch (std::exception& e) {
100541       {
100542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100543       };
100544     } catch (...) {
100545       {
100546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100547       };
100548     }
100549   }
100550 }
100551
100552
100553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
100554   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100555   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100556   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100557
100558   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100559   arg2 = (Dali::SlotObserver *)jarg2;
100560   arg3 = (Dali::CallbackBase *)jarg3;
100561   {
100562     try {
100563       (arg1)->SignalDisconnected(arg2,arg3);
100564     } catch (std::out_of_range& e) {
100565       {
100566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100567       };
100568     } catch (std::exception& e) {
100569       {
100570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100571       };
100572     } catch (...) {
100573       {
100574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100575       };
100576     }
100577   }
100578 }
100579
100580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
100581   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100582   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100583   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100584
100585   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100586   arg2 = (Dali::SlotObserver *)jarg2;
100587   arg3 = (Dali::CallbackBase *)jarg3;
100588   {
100589     try {
100590       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
100591     } catch (std::out_of_range& e) {
100592       {
100593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100594       };
100595     } catch (std::exception& e) {
100596       {
100597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100598       };
100599     } catch (...) {
100600       {
100601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100602       };
100603     }
100604   }
100605 }
100606
100607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
100608   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100609   std::string *arg2 = 0 ;
100610
100611   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100612   if (!jarg2) {
100613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100614     return ;
100615   }
100616   std::string arg2_str(jarg2);
100617   arg2 = &arg2_str;
100618   {
100619     try {
100620       (arg1)->SetContentInfo((std::string const &)*arg2);
100621     } catch (std::out_of_range& e) {
100622       {
100623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100624       };
100625     } catch (std::exception& e) {
100626       {
100627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100628       };
100629     } catch (...) {
100630       {
100631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100632       };
100633     }
100634   }
100635 }
100636
100637
100638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
100639   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100640   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
100641
100642   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100643   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
100644   {
100645     try {
100646       (arg1)->SetImpl(arg2);
100647     } catch (std::out_of_range& e) {
100648       {
100649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100650       };
100651     } catch (std::exception& e) {
100652       {
100653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100654       };
100655     } catch (...) {
100656       {
100657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100658       };
100659     }
100660   }
100661 }
100662
100663 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) {
100664
100665   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
100666   if (director) {
100667     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
100668   }
100669 }
100670
100671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
100672   void * jresult ;
100673   Dali::Widget *arg1 = 0 ;
100674   SwigDirector_WidgetImpl *result = 0 ;
100675
100676   arg1 = (Dali::Widget *)jarg1;
100677   if (!arg1) {
100678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
100679     return 0;
100680   }
100681   {
100682     try {
100683       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
100684     } catch (std::out_of_range& e) {
100685       {
100686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100687       };
100688     } catch (std::exception& e) {
100689       {
100690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100691       };
100692     } catch (...) {
100693       {
100694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100695       };
100696     }
100697   }
100698
100699   jresult = (void *)result;
100700   return jresult;
100701 }
100702
100703
100704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
100705   void * jresult ;
100706   int *arg1 = (int *) 0 ;
100707   char ***arg2 ;
100708   std::string *arg3 = 0 ;
100709   Dali::WidgetApplication result;
100710   {
100711     int index = 0;
100712     int length = 0;
100713     char *retPtr;
100714     char *nextPtr;
100715     argWidgetC = jarg1;
100716     argWidgetV = new char*[jarg1 + 1];
100717
100718     retPtr = strtok_r( jarg2, " ", &nextPtr);
100719     if( retPtr )
100720     {
100721       length = strlen(retPtr);
100722     }
100723     argWidgetV[index] = new char[length + 1];
100724     if( retPtr )
100725     {
100726       strncpy(argWidgetV[index], retPtr, length);
100727     }
100728     argWidgetV[index][length] = '\0';
100729     index++;
100730
100731     while (index < jarg1)
100732     {
100733       length = 0;
100734       retPtr = strtok_r(NULL, " ", &nextPtr);
100735       if( retPtr )
100736       {
100737         length = strlen(retPtr);
100738       }
100739       argWidgetV[index] = new char[length + 1];
100740       if( retPtr )
100741       {
100742         strncpy(argWidgetV[index], retPtr, length);
100743       }
100744       argWidgetV[index][length] = '\0';
100745       index++;
100746     }
100747
100748     argWidgetV[jarg1] = NULL;
100749     argWidgetC = jarg1;
100750
100751     arg1 = &argWidgetC;
100752     arg2 = &argWidgetV;
100753   }
100754
100755   if (!jarg3) {
100756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100757     return 0;
100758   }
100759   std::string arg3_str(jarg3);
100760   arg3 = &arg3_str;
100761   {
100762     try {
100763       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
100764     } catch (std::out_of_range& e) {
100765       {
100766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100767       };
100768     } catch (std::exception& e) {
100769       {
100770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100771       };
100772     } catch (...) {
100773       {
100774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100775       };
100776     }
100777   }
100778   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
100779
100780   return jresult;
100781 }
100782
100783
100784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
100785   void * jresult ;
100786   Dali::WidgetApplication *result = 0 ;
100787
100788   {
100789     try {
100790       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
100791     } catch (std::out_of_range& e) {
100792       {
100793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100794       };
100795     } catch (std::exception& e) {
100796       {
100797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100798       };
100799     } catch (...) {
100800       {
100801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100802       };
100803     }
100804   }
100805   jresult = (void *)result;
100806   return jresult;
100807 }
100808
100809
100810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
100811   void * jresult ;
100812   Dali::WidgetApplication *arg1 = 0 ;
100813   Dali::WidgetApplication *result = 0 ;
100814
100815   arg1 = (Dali::WidgetApplication *)jarg1;
100816   if (!arg1) {
100817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
100818     return 0;
100819   }
100820   {
100821     try {
100822       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
100823     } catch (std::out_of_range& e) {
100824       {
100825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100826       };
100827     } catch (std::exception& e) {
100828       {
100829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100830       };
100831     } catch (...) {
100832       {
100833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100834       };
100835     }
100836   }
100837   jresult = (void *)result;
100838   return jresult;
100839 }
100840
100841
100842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
100843   void * jresult ;
100844   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100845   Dali::WidgetApplication *arg2 = 0 ;
100846   Dali::WidgetApplication *result = 0 ;
100847
100848   arg1 = (Dali::WidgetApplication *)jarg1;
100849   arg2 = (Dali::WidgetApplication *)jarg2;
100850   if (!arg2) {
100851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
100852     return 0;
100853   }
100854   {
100855     try {
100856       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
100857     } catch (std::out_of_range& e) {
100858       {
100859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100860       };
100861     } catch (std::exception& e) {
100862       {
100863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100864       };
100865     } catch (...) {
100866       {
100867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100868       };
100869     }
100870   }
100871   jresult = (void *)result;
100872   return jresult;
100873 }
100874
100875
100876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
100877   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100878
100879   arg1 = (Dali::WidgetApplication *)jarg1;
100880   {
100881     try {
100882       delete arg1;
100883       if( argWidgetV )
100884       {
100885         // free string data
100886         for( int i=0; i < argWidgetC+1; i++)
100887         {
100888           delete [] argWidgetV[i];
100889         }
100890         delete [] argWidgetV;
100891       }
100892     } catch (std::out_of_range& e) {
100893       {
100894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100895       };
100896     } catch (std::exception& e) {
100897       {
100898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100899       };
100900     } catch (...) {
100901       {
100902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100903       };
100904     }
100905   }
100906 }
100907
100908
100909 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
100910 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
100911
100912 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
100913 {
100914   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
100915   return *widget;
100916 }
100917
100918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
100919   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100920   std::string *arg2 = 0 ;
100921
100922   arg1 = (Dali::WidgetApplication *)jarg1;
100923   if (!jarg2) {
100924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100925     return ;
100926   }
100927   std::string arg2_str(*jarg2);
100928   arg2 = &arg2_str;
100929
100930   if(!_CSharpCreateWidgetFunction)
100931   {
100932     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
100933   }
100934
100935   {
100936     try {
100937       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
100938     } catch (std::out_of_range& e) {
100939       {
100940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100941       };
100942     } catch (std::exception& e) {
100943       {
100944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100945       };
100946     } catch (...) {
100947       {
100948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100949       };
100950     }
100951   }
100952
100953   //Typemap argout in c++ file.
100954   //This will convert c++ string to c# string
100955   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
100956 }
100957
100958
100959 //for PixelBuffer and ImageLoading
100960
100961 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
100962     return (Dali::BaseHandle *)jarg1;
100963 }
100964
100965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
100966   void * jresult ;
100967   unsigned int arg1 ;
100968   unsigned int arg2 ;
100969   Dali::Pixel::Format arg3 ;
100970   Dali::Devel::PixelBuffer result;
100971
100972   arg1 = (unsigned int)jarg1;
100973   arg2 = (unsigned int)jarg2;
100974   arg3 = (Dali::Pixel::Format)jarg3;
100975   {
100976     try {
100977       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
100978     } catch (std::out_of_range& e) {
100979       {
100980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100981       };
100982     } catch (std::exception& e) {
100983       {
100984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100985       };
100986     } catch (...) {
100987       {
100988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100989       };
100990     }
100991   }
100992   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
100993   return jresult;
100994 }
100995
100996
100997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
100998   void * jresult ;
100999   Dali::Devel::PixelBuffer *result = 0 ;
101000
101001   {
101002     try {
101003       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
101004     } catch (std::out_of_range& e) {
101005       {
101006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101007       };
101008     } catch (std::exception& e) {
101009       {
101010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101011       };
101012     } catch (...) {
101013       {
101014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101015       };
101016     }
101017   }
101018   jresult = (void *)result;
101019   return jresult;
101020 }
101021
101022
101023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
101024   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101025
101026   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101027   {
101028     try {
101029       delete arg1;
101030     } catch (std::out_of_range& e) {
101031       {
101032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101033       };
101034     } catch (std::exception& e) {
101035       {
101036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101037       };
101038     } catch (...) {
101039       {
101040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101041       };
101042     }
101043   }
101044 }
101045
101046
101047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
101048   void * jresult ;
101049   Dali::Devel::PixelBuffer *arg1 = 0 ;
101050   Dali::Devel::PixelBuffer *result = 0 ;
101051
101052   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101053   if (!arg1) {
101054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101055     return 0;
101056   }
101057   {
101058     try {
101059       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
101060     } catch (std::out_of_range& e) {
101061       {
101062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101063       };
101064     } catch (std::exception& e) {
101065       {
101066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101067       };
101068     } catch (...) {
101069       {
101070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101071       };
101072     }
101073   }
101074   jresult = (void *)result;
101075   return jresult;
101076 }
101077
101078
101079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
101080   void * jresult ;
101081   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101082   Dali::Devel::PixelBuffer *arg2 = 0 ;
101083   Dali::Devel::PixelBuffer *result = 0 ;
101084
101085   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101086   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
101087   if (!arg2) {
101088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101089     return 0;
101090   }
101091   {
101092     try {
101093       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
101094     } catch (std::out_of_range& e) {
101095       {
101096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101097       };
101098     } catch (std::exception& e) {
101099       {
101100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101101       };
101102     } catch (...) {
101103       {
101104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101105       };
101106     }
101107   }
101108   jresult = (void *)result;
101109   return jresult;
101110 }
101111
101112
101113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
101114   void * jresult ;
101115   Dali::Devel::PixelBuffer *arg1 = 0 ;
101116   Dali::PixelData result;
101117
101118   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101119   if (!arg1) {
101120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
101121     return 0;
101122   }
101123   {
101124     try {
101125       result = Dali::Devel::PixelBuffer::Convert(*arg1);
101126     } catch (std::out_of_range& e) {
101127       {
101128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101129       };
101130     } catch (std::exception& e) {
101131       {
101132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101133       };
101134     } catch (...) {
101135       {
101136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101137       };
101138     }
101139   }
101140   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101141   return jresult;
101142 }
101143
101144
101145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
101146   void * jresult ;
101147   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101148   Dali::PixelData result;
101149
101150   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101151   {
101152     try {
101153       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
101154     } catch (std::out_of_range& e) {
101155       {
101156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101157       };
101158     } catch (std::exception& e) {
101159       {
101160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101161       };
101162     } catch (...) {
101163       {
101164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101165       };
101166     }
101167   }
101168   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101169   return jresult;
101170 }
101171
101172
101173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
101174   void * jresult ;
101175   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101176   unsigned char *result = 0 ;
101177
101178   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101179   {
101180     try {
101181       result = (unsigned char *)(arg1)->GetBuffer();
101182     } catch (std::out_of_range& e) {
101183       {
101184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101185       };
101186     } catch (std::exception& e) {
101187       {
101188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101189       };
101190     } catch (...) {
101191       {
101192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101193       };
101194     }
101195   }
101196   jresult = (void *)result;
101197   return jresult;
101198 }
101199
101200
101201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
101202   unsigned int jresult ;
101203   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101204   unsigned int result;
101205
101206   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101207   {
101208     try {
101209       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
101210     } catch (std::out_of_range& e) {
101211       {
101212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101213       };
101214     } catch (std::exception& e) {
101215       {
101216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101217       };
101218     } catch (...) {
101219       {
101220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101221       };
101222     }
101223   }
101224   jresult = result;
101225   return jresult;
101226 }
101227
101228
101229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
101230   unsigned int jresult ;
101231   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101232   unsigned int result;
101233
101234   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101235   {
101236     try {
101237       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
101238     } catch (std::out_of_range& e) {
101239       {
101240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101241       };
101242     } catch (std::exception& e) {
101243       {
101244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101245       };
101246     } catch (...) {
101247       {
101248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101249       };
101250     }
101251   }
101252   jresult = result;
101253   return jresult;
101254 }
101255
101256
101257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
101258   int jresult ;
101259   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101260   Dali::Pixel::Format result;
101261
101262   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101263   {
101264     try {
101265       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
101266     } catch (std::out_of_range& e) {
101267       {
101268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101269       };
101270     } catch (std::exception& e) {
101271       {
101272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101273       };
101274     } catch (...) {
101275       {
101276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101277       };
101278     }
101279   }
101280   jresult = (int)result;
101281   return jresult;
101282 }
101283
101284
101285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
101286   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101287   Dali::Devel::PixelBuffer arg2 ;
101288   float arg3 ;
101289   bool arg4 ;
101290   Dali::Devel::PixelBuffer *argp2 ;
101291
101292   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101293   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101294   if (!argp2) {
101295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101296     return ;
101297   }
101298   arg2 = *argp2;
101299   arg3 = (float)jarg3;
101300   arg4 = jarg4 ? true : false;
101301   {
101302     try {
101303       (arg1)->ApplyMask(arg2,arg3,arg4);
101304     } catch (std::out_of_range& e) {
101305       {
101306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101307       };
101308     } catch (std::exception& e) {
101309       {
101310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101311       };
101312     } catch (...) {
101313       {
101314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101315       };
101316     }
101317   }
101318 }
101319
101320
101321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
101322   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101323   Dali::Devel::PixelBuffer arg2 ;
101324   float arg3 ;
101325   Dali::Devel::PixelBuffer *argp2 ;
101326
101327   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101328   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101329   if (!argp2) {
101330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101331     return ;
101332   }
101333   arg2 = *argp2;
101334   arg3 = (float)jarg3;
101335   {
101336     try {
101337       (arg1)->ApplyMask(arg2,arg3);
101338     } catch (std::out_of_range& e) {
101339       {
101340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101341       };
101342     } catch (std::exception& e) {
101343       {
101344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101345       };
101346     } catch (...) {
101347       {
101348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101349       };
101350     }
101351   }
101352 }
101353
101354
101355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
101356   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101357   Dali::Devel::PixelBuffer arg2 ;
101358   Dali::Devel::PixelBuffer *argp2 ;
101359
101360   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101361   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101362   if (!argp2) {
101363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101364     return ;
101365   }
101366   arg2 = *argp2;
101367   {
101368     try {
101369       (arg1)->ApplyMask(arg2);
101370     } catch (std::out_of_range& e) {
101371       {
101372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101373       };
101374     } catch (std::exception& e) {
101375       {
101376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101377       };
101378     } catch (...) {
101379       {
101380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101381       };
101382     }
101383   }
101384 }
101385
101386
101387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
101388   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101389   float arg2 ;
101390
101391   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101392   arg2 = (float)jarg2;
101393   {
101394     try {
101395       (arg1)->ApplyGaussianBlur(arg2);
101396     } catch (std::out_of_range& e) {
101397       {
101398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101399       };
101400     } catch (std::exception& e) {
101401       {
101402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101403       };
101404     } catch (...) {
101405       {
101406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101407       };
101408     }
101409   }
101410 }
101411
101412
101413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
101414   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101415   uint16_t arg2 ;
101416   uint16_t arg3 ;
101417   uint16_t arg4 ;
101418   uint16_t arg5 ;
101419
101420   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101421   arg2 = (uint16_t)jarg2;
101422   arg3 = (uint16_t)jarg3;
101423   arg4 = (uint16_t)jarg4;
101424   arg5 = (uint16_t)jarg5;
101425   {
101426     try {
101427       (arg1)->Crop(arg2,arg3,arg4,arg5);
101428     } catch (std::out_of_range& e) {
101429       {
101430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101431       };
101432     } catch (std::exception& e) {
101433       {
101434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101435       };
101436     } catch (...) {
101437       {
101438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101439       };
101440     }
101441   }
101442 }
101443
101444
101445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
101446   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101447   uint16_t arg2 ;
101448   uint16_t arg3 ;
101449
101450   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101451   arg2 = (uint16_t)jarg2;
101452   arg3 = (uint16_t)jarg3;
101453   {
101454     try {
101455       (arg1)->Resize(arg2,arg3);
101456     } catch (std::out_of_range& e) {
101457       {
101458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101459       };
101460     } catch (std::exception& e) {
101461       {
101462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101463       };
101464     } catch (...) {
101465       {
101466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101467       };
101468     }
101469   }
101470 }
101471
101472
101473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101474   void * jresult ;
101475   std::string *arg1 = 0 ;
101476   Dali::ImageDimensions arg2 ;
101477   Dali::FittingMode::Type arg3 ;
101478   Dali::SamplingMode::Type arg4 ;
101479   bool arg5 ;
101480   Dali::ImageDimensions *argp2 ;
101481   Dali::Devel::PixelBuffer result;
101482
101483   if (!jarg1) {
101484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101485     return 0;
101486   }
101487   std::string arg1_str(jarg1);
101488   arg1 = &arg1_str;
101489   argp2 = (Dali::ImageDimensions *)jarg2;
101490   if (!argp2) {
101491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101492     return 0;
101493   }
101494   arg2 = *argp2;
101495   arg3 = (Dali::FittingMode::Type)jarg3;
101496   arg4 = (Dali::SamplingMode::Type)jarg4;
101497   arg5 = jarg5 ? true : false;
101498   {
101499     try {
101500       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101501     } catch (std::out_of_range& e) {
101502       {
101503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101504       };
101505     } catch (std::exception& e) {
101506       {
101507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101508       };
101509     } catch (...) {
101510       {
101511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101512       };
101513     }
101514   }
101515   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101516
101517   return jresult;
101518 }
101519
101520
101521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101522   void * jresult ;
101523   std::string *arg1 = 0 ;
101524   Dali::ImageDimensions arg2 ;
101525   Dali::FittingMode::Type arg3 ;
101526   Dali::SamplingMode::Type arg4 ;
101527   Dali::ImageDimensions *argp2 ;
101528   Dali::Devel::PixelBuffer result;
101529
101530   if (!jarg1) {
101531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101532     return 0;
101533   }
101534   std::string arg1_str(jarg1);
101535   arg1 = &arg1_str;
101536   argp2 = (Dali::ImageDimensions *)jarg2;
101537   if (!argp2) {
101538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101539     return 0;
101540   }
101541   arg2 = *argp2;
101542   arg3 = (Dali::FittingMode::Type)jarg3;
101543   arg4 = (Dali::SamplingMode::Type)jarg4;
101544   {
101545     try {
101546       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
101547     } catch (std::out_of_range& e) {
101548       {
101549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101550       };
101551     } catch (std::exception& e) {
101552       {
101553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101554       };
101555     } catch (...) {
101556       {
101557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101558       };
101559     }
101560   }
101561   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101562
101563   return jresult;
101564 }
101565
101566
101567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101568   void * jresult ;
101569   std::string *arg1 = 0 ;
101570   Dali::ImageDimensions arg2 ;
101571   Dali::FittingMode::Type arg3 ;
101572   Dali::ImageDimensions *argp2 ;
101573   Dali::Devel::PixelBuffer result;
101574
101575   if (!jarg1) {
101576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101577     return 0;
101578   }
101579   std::string arg1_str(jarg1);
101580   arg1 = &arg1_str;
101581   argp2 = (Dali::ImageDimensions *)jarg2;
101582   if (!argp2) {
101583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101584     return 0;
101585   }
101586   arg2 = *argp2;
101587   arg3 = (Dali::FittingMode::Type)jarg3;
101588   {
101589     try {
101590       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
101591     } catch (std::out_of_range& e) {
101592       {
101593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101594       };
101595     } catch (std::exception& e) {
101596       {
101597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101598       };
101599     } catch (...) {
101600       {
101601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101602       };
101603     }
101604   }
101605   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101606
101607   return jresult;
101608 }
101609
101610
101611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
101612   void * jresult ;
101613   std::string *arg1 = 0 ;
101614   Dali::ImageDimensions arg2 ;
101615   Dali::ImageDimensions *argp2 ;
101616   Dali::Devel::PixelBuffer result;
101617
101618   if (!jarg1) {
101619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101620     return 0;
101621   }
101622   std::string arg1_str(jarg1);
101623   arg1 = &arg1_str;
101624   argp2 = (Dali::ImageDimensions *)jarg2;
101625   if (!argp2) {
101626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101627     return 0;
101628   }
101629   arg2 = *argp2;
101630   {
101631     try {
101632       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
101633     } catch (std::out_of_range& e) {
101634       {
101635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101636       };
101637     } catch (std::exception& e) {
101638       {
101639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101640       };
101641     } catch (...) {
101642       {
101643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101644       };
101645     }
101646   }
101647   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101648
101649   return jresult;
101650 }
101651
101652
101653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
101654   void * jresult ;
101655   std::string *arg1 = 0 ;
101656   Dali::Devel::PixelBuffer result;
101657
101658   if (!jarg1) {
101659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101660     return 0;
101661   }
101662   std::string arg1_str(jarg1);
101663   arg1 = &arg1_str;
101664   {
101665     try {
101666       result = Dali::LoadImageFromFile((std::string const &)*arg1);
101667     } catch (std::out_of_range& e) {
101668       {
101669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101670       };
101671     } catch (std::exception& e) {
101672       {
101673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101674       };
101675     } catch (...) {
101676       {
101677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101678       };
101679     }
101680   }
101681   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101682
101683   return jresult;
101684 }
101685
101686
101687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101688   void * jresult ;
101689   std::string *arg1 = 0 ;
101690   Dali::ImageDimensions arg2 ;
101691   Dali::FittingMode::Type arg3 ;
101692   Dali::SamplingMode::Type arg4 ;
101693   bool arg5 ;
101694   Dali::ImageDimensions *argp2 ;
101695   Dali::ImageDimensions result;
101696
101697   if (!jarg1) {
101698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101699     return 0;
101700   }
101701   std::string arg1_str(jarg1);
101702   arg1 = &arg1_str;
101703   argp2 = (Dali::ImageDimensions *)jarg2;
101704   if (!argp2) {
101705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101706     return 0;
101707   }
101708   arg2 = *argp2;
101709   arg3 = (Dali::FittingMode::Type)jarg3;
101710   arg4 = (Dali::SamplingMode::Type)jarg4;
101711   arg5 = jarg5 ? true : false;
101712   {
101713     try {
101714       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101715     } catch (std::out_of_range& e) {
101716       {
101717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101718       };
101719     } catch (std::exception& e) {
101720       {
101721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101722       };
101723     } catch (...) {
101724       {
101725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101726       };
101727     }
101728   }
101729   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101730
101731   return jresult;
101732 }
101733
101734
101735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101736   void * jresult ;
101737   std::string *arg1 = 0 ;
101738   Dali::ImageDimensions arg2 ;
101739   Dali::FittingMode::Type arg3 ;
101740   Dali::SamplingMode::Type arg4 ;
101741   Dali::ImageDimensions *argp2 ;
101742   Dali::ImageDimensions result;
101743
101744   if (!jarg1) {
101745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101746     return 0;
101747   }
101748   std::string arg1_str(jarg1);
101749   arg1 = &arg1_str;
101750   argp2 = (Dali::ImageDimensions *)jarg2;
101751   if (!argp2) {
101752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101753     return 0;
101754   }
101755   arg2 = *argp2;
101756   arg3 = (Dali::FittingMode::Type)jarg3;
101757   arg4 = (Dali::SamplingMode::Type)jarg4;
101758   {
101759     try {
101760       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
101761     } catch (std::out_of_range& e) {
101762       {
101763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101764       };
101765     } catch (std::exception& e) {
101766       {
101767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101768       };
101769     } catch (...) {
101770       {
101771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101772       };
101773     }
101774   }
101775   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101776
101777   return jresult;
101778 }
101779
101780
101781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101782   void * jresult ;
101783   std::string *arg1 = 0 ;
101784   Dali::ImageDimensions arg2 ;
101785   Dali::FittingMode::Type arg3 ;
101786   Dali::ImageDimensions *argp2 ;
101787   Dali::ImageDimensions result;
101788
101789   if (!jarg1) {
101790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101791     return 0;
101792   }
101793   std::string arg1_str(jarg1);
101794   arg1 = &arg1_str;
101795   argp2 = (Dali::ImageDimensions *)jarg2;
101796   if (!argp2) {
101797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101798     return 0;
101799   }
101800   arg2 = *argp2;
101801   arg3 = (Dali::FittingMode::Type)jarg3;
101802   {
101803     try {
101804       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
101805     } catch (std::out_of_range& e) {
101806       {
101807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101808       };
101809     } catch (std::exception& e) {
101810       {
101811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101812       };
101813     } catch (...) {
101814       {
101815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101816       };
101817     }
101818   }
101819   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101820
101821   return jresult;
101822 }
101823
101824
101825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
101826   void * jresult ;
101827   std::string *arg1 = 0 ;
101828   Dali::ImageDimensions arg2 ;
101829   Dali::ImageDimensions *argp2 ;
101830   Dali::ImageDimensions result;
101831
101832   if (!jarg1) {
101833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101834     return 0;
101835   }
101836   std::string arg1_str(jarg1);
101837   arg1 = &arg1_str;
101838   argp2 = (Dali::ImageDimensions *)jarg2;
101839   if (!argp2) {
101840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101841     return 0;
101842   }
101843   arg2 = *argp2;
101844   {
101845     try {
101846       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
101847     } catch (std::out_of_range& e) {
101848       {
101849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101850       };
101851     } catch (std::exception& e) {
101852       {
101853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101854       };
101855     } catch (...) {
101856       {
101857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101858       };
101859     }
101860   }
101861   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101862
101863   return jresult;
101864 }
101865
101866
101867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
101868   void * jresult ;
101869   std::string *arg1 = 0 ;
101870   Dali::ImageDimensions result;
101871
101872   if (!jarg1) {
101873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101874     return 0;
101875   }
101876   std::string arg1_str(jarg1);
101877   arg1 = &arg1_str;
101878   {
101879     try {
101880       result = Dali::GetClosestImageSize((std::string const &)*arg1);
101881     } catch (std::out_of_range& e) {
101882       {
101883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101884       };
101885     } catch (std::exception& e) {
101886       {
101887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101888       };
101889     } catch (...) {
101890       {
101891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101892       };
101893     }
101894   }
101895   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101896
101897   return jresult;
101898 }
101899
101900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
101901   void * jresult ;
101902   std::string *arg1 = 0 ;
101903   Dali::ImageDimensions result;
101904
101905   if (!jarg1) {
101906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101907     return 0;
101908   }
101909   std::string arg1_str(jarg1);
101910   arg1 = &arg1_str;
101911   {
101912     try {
101913       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
101914     } catch (std::out_of_range& e) {
101915       {
101916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101917       };
101918     } catch (std::exception& e) {
101919       {
101920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101921       };
101922     } catch (...) {
101923       {
101924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101925       };
101926     }
101927   }
101928   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101929
101930   return jresult;
101931 }
101932
101933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101934   void * jresult ;
101935   std::string *arg1 = 0 ;
101936   Dali::ImageDimensions arg2 ;
101937   Dali::FittingMode::Type arg3 ;
101938   Dali::SamplingMode::Type arg4 ;
101939   bool arg5 ;
101940   Dali::ImageDimensions *argp2 ;
101941   Dali::Devel::PixelBuffer result;
101942
101943   if (!jarg1) {
101944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101945     return 0;
101946   }
101947   std::string arg1_str(jarg1);
101948   arg1 = &arg1_str;
101949   argp2 = (Dali::ImageDimensions *)jarg2;
101950   if (!argp2) {
101951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101952     return 0;
101953   }
101954   arg2 = *argp2;
101955   arg3 = (Dali::FittingMode::Type)jarg3;
101956   arg4 = (Dali::SamplingMode::Type)jarg4;
101957   arg5 = jarg5 ? true : false;
101958   {
101959     try {
101960       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101961     } catch (std::out_of_range& e) {
101962       {
101963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101964       };
101965     } catch (std::exception& e) {
101966       {
101967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101968       };
101969     } catch (...) {
101970       {
101971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101972       };
101973     }
101974   }
101975   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101976
101977   return jresult;
101978 }
101979
101980
101981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101982   void * jresult ;
101983   std::string *arg1 = 0 ;
101984   Dali::ImageDimensions arg2 ;
101985   Dali::FittingMode::Type arg3 ;
101986   Dali::SamplingMode::Type arg4 ;
101987   Dali::ImageDimensions *argp2 ;
101988   Dali::Devel::PixelBuffer result;
101989
101990   if (!jarg1) {
101991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101992     return 0;
101993   }
101994   std::string arg1_str(jarg1);
101995   arg1 = &arg1_str;
101996   argp2 = (Dali::ImageDimensions *)jarg2;
101997   if (!argp2) {
101998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101999     return 0;
102000   }
102001   arg2 = *argp2;
102002   arg3 = (Dali::FittingMode::Type)jarg3;
102003   arg4 = (Dali::SamplingMode::Type)jarg4;
102004   {
102005     try {
102006       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
102007     } catch (std::out_of_range& e) {
102008       {
102009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102010       };
102011     } catch (std::exception& e) {
102012       {
102013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102014       };
102015     } catch (...) {
102016       {
102017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102018       };
102019     }
102020   }
102021   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102022
102023   return jresult;
102024 }
102025
102026
102027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102028   void * jresult ;
102029   std::string *arg1 = 0 ;
102030   Dali::ImageDimensions arg2 ;
102031   Dali::FittingMode::Type arg3 ;
102032   Dali::ImageDimensions *argp2 ;
102033   Dali::Devel::PixelBuffer result;
102034
102035   if (!jarg1) {
102036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102037     return 0;
102038   }
102039   std::string arg1_str(jarg1);
102040   arg1 = &arg1_str;
102041   argp2 = (Dali::ImageDimensions *)jarg2;
102042   if (!argp2) {
102043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102044     return 0;
102045   }
102046   arg2 = *argp2;
102047   arg3 = (Dali::FittingMode::Type)jarg3;
102048   {
102049     try {
102050       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
102051     } catch (std::out_of_range& e) {
102052       {
102053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102054       };
102055     } catch (std::exception& e) {
102056       {
102057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102058       };
102059     } catch (...) {
102060       {
102061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102062       };
102063     }
102064   }
102065   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102066
102067   return jresult;
102068 }
102069
102070
102071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
102072   void * jresult ;
102073   std::string *arg1 = 0 ;
102074   Dali::ImageDimensions arg2 ;
102075   Dali::ImageDimensions *argp2 ;
102076   Dali::Devel::PixelBuffer result;
102077
102078   if (!jarg1) {
102079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102080     return 0;
102081   }
102082   std::string arg1_str(jarg1);
102083   arg1 = &arg1_str;
102084   argp2 = (Dali::ImageDimensions *)jarg2;
102085   if (!argp2) {
102086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102087     return 0;
102088   }
102089   arg2 = *argp2;
102090   {
102091     try {
102092       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
102093     } catch (std::out_of_range& e) {
102094       {
102095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102096       };
102097     } catch (std::exception& e) {
102098       {
102099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102100       };
102101     } catch (...) {
102102       {
102103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102104       };
102105     }
102106   }
102107   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102108
102109   return jresult;
102110 }
102111
102112
102113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
102114   void * jresult ;
102115   std::string *arg1 = 0 ;
102116   Dali::Devel::PixelBuffer result;
102117
102118   if (!jarg1) {
102119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102120     return 0;
102121   }
102122   std::string arg1_str(jarg1);
102123   arg1 = &arg1_str;
102124   {
102125     try {
102126       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
102127     } catch (std::out_of_range& e) {
102128       {
102129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102130       };
102131     } catch (std::exception& e) {
102132       {
102133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102134       };
102135     } catch (...) {
102136       {
102137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102138       };
102139     }
102140   }
102141   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102142
102143   return jresult;
102144 }
102145
102146
102147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
102148   void * jresult ;
102149   Dali::Toolkit::WebView result;
102150
102151   {
102152     try {
102153       result = Dali::Toolkit::WebView::New();
102154     } catch (std::out_of_range& e) {
102155       {
102156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102157       };
102158     } catch (std::exception& e) {
102159       {
102160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102161       };
102162     } catch (Dali::DaliException e) {
102163       {
102164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102165       };
102166     } catch (...) {
102167       {
102168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102169       };
102170     }
102171   }
102172   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102173   return jresult;
102174 }
102175
102176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
102177   void * jresult ;
102178   Dali::Toolkit::WebView result;
102179
102180   std::string *arg1;
102181   std::string *arg2;
102182
102183   if (!jarg1) {
102184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
102185     return 0;
102186   }
102187   if (!jarg2) {
102188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
102189     return 0;
102190   }
102191
102192   std::string jarg1_str = std::string(jarg1);
102193   std::string jarg2_str = std::string(jarg2);
102194
102195   arg1 = &jarg1_str;
102196   arg2 = &jarg2_str;
102197
102198   {
102199     try {
102200       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
102201     } catch (std::out_of_range& e) {
102202       {
102203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102204       };
102205     } catch (std::exception& e) {
102206       {
102207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102208       };
102209     } catch (Dali::DaliException e) {
102210       {
102211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102212       };
102213     } catch (...) {
102214       {
102215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102216       };
102217     }
102218   }
102219   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102220   return jresult;
102221 }
102222
102223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
102224   void * jresult ;
102225   Dali::Toolkit::WebView *arg1 = 0 ;
102226   Dali::Toolkit::WebView *result = 0 ;
102227
102228   arg1 = (Dali::Toolkit::WebView *)jarg1;
102229   if (!arg1) {
102230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
102231     return 0;
102232   }
102233   {
102234     try {
102235       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
102236     } catch (std::out_of_range& e) {
102237       {
102238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102239       };
102240     } catch (std::exception& e) {
102241       {
102242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102243       };
102244     } catch (Dali::DaliException e) {
102245       {
102246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102247       };
102248     } catch (...) {
102249       {
102250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102251       };
102252     }
102253   }
102254   jresult = (void *)result;
102255   return jresult;
102256 }
102257
102258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
102259   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102260   arg1 = (Dali::Toolkit::WebView *)jarg1;
102261   {
102262     try {
102263       delete arg1;
102264     } catch (std::out_of_range& e) {
102265       {
102266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102267       };
102268     } catch (std::exception& e) {
102269       {
102270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102271       };
102272     } catch (Dali::DaliException e) {
102273       {
102274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102275       };
102276     } catch (...) {
102277       {
102278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102279       };
102280     }
102281   }
102282 }
102283
102284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
102285   void * jresult ;
102286   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102287   Dali::Toolkit::WebView *arg2 = 0 ;
102288   Dali::Toolkit::WebView *result = 0 ;
102289
102290   arg1 = (Dali::Toolkit::WebView *)jarg1;
102291   arg2 = (Dali::Toolkit::WebView *)jarg2;
102292   if (!arg2) {
102293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
102294     return 0;
102295   }
102296   {
102297     try {
102298       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
102299     } catch (std::out_of_range& e) {
102300       {
102301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102302       };
102303     } catch (std::exception& e) {
102304       {
102305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102306       };
102307     } catch (Dali::DaliException e) {
102308       {
102309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102310       };
102311     } catch (...) {
102312       {
102313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102314       };
102315     }
102316   }
102317   jresult = (void *)result;
102318   return jresult;
102319 }
102320
102321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
102322   void * jresult ;
102323   Dali::BaseHandle arg1 ;
102324   Dali::BaseHandle *argp1 ;
102325   Dali::Toolkit::WebView result;
102326
102327   argp1 = (Dali::BaseHandle *)jarg1;
102328   if (!argp1) {
102329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
102330     return 0;
102331   }
102332   arg1 = *argp1;
102333   {
102334     try {
102335       result = Dali::Toolkit::WebView::DownCast(arg1);
102336     } catch (std::out_of_range& e) {
102337       {
102338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102339       };
102340     } catch (std::exception& e) {
102341       {
102342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102343       };
102344     } catch (Dali::DaliException e) {
102345       {
102346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102347       };
102348     } catch (...) {
102349       {
102350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102351       };
102352     }
102353   }
102354   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102355   return jresult;
102356 }
102357
102358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
102359   return (int) Dali::Toolkit::WebView::Property::URL;
102360 }
102361
102362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
102363   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
102364 }
102365
102366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
102367   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
102368 }
102369
102370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
102371   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
102372 }
102373
102374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
102375   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
102376 }
102377
102378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
102379   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
102380 }
102381
102382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
102383   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
102384 }
102385
102386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
102387   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
102388 }
102389
102390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
102391   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102392   std::string *arg2;
102393
102394   arg1 = (Dali::Toolkit::WebView *)jarg1;
102395
102396   if (!jarg2) {
102397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102398     return;
102399   }
102400
102401   std::string jarg2str = std::string(jarg2);
102402   arg2 = &jarg2str;
102403   {
102404     try {
102405       (arg1)->LoadUrl((std::string const &)*arg2);
102406     } catch (std::out_of_range& e) {
102407       {
102408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102409       };
102410     } catch (std::exception& e) {
102411       {
102412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102413       };
102414     } catch (Dali::DaliException e) {
102415       {
102416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102417       };
102418     } catch (...) {
102419       {
102420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102421       };
102422     }
102423   }
102424 }
102425
102426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
102427   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102428   std::string *arg2;
102429
102430   arg1 = (Dali::Toolkit::WebView *)jarg1;
102431   if (!jarg2) {
102432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102433     return;
102434   }
102435   std::string jarg2str = std::string(jarg2);
102436   arg2 = &jarg2str;
102437   {
102438     try {
102439       (arg1)->LoadHTMLString((std::string const &)*arg2);
102440     } catch (std::out_of_range& e) {
102441       {
102442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102443       };
102444     } catch (std::exception& e) {
102445       {
102446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102447       };
102448     } catch (Dali::DaliException e) {
102449       {
102450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102451       };
102452     } catch (...) {
102453       {
102454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102455       };
102456     }
102457   }
102458 }
102459
102460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
102461   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102462
102463   arg1 = (Dali::Toolkit::WebView *)jarg1;
102464   {
102465     try {
102466       (arg1)->Reload();
102467     } catch (std::out_of_range& e) {
102468       {
102469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102470       };
102471     } catch (std::exception& e) {
102472       {
102473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102474       };
102475     } catch (Dali::DaliException e) {
102476       {
102477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102478       };
102479     } catch (...) {
102480       {
102481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102482       };
102483     }
102484   }
102485 }
102486
102487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
102488   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102489
102490   arg1 = (Dali::Toolkit::WebView *)jarg1;
102491   {
102492     try {
102493       (arg1)->StopLoading();
102494     } catch (std::out_of_range& e) {
102495       {
102496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102497       };
102498     } catch (std::exception& e) {
102499       {
102500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102501       };
102502     } catch (Dali::DaliException e) {
102503       {
102504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102505       };
102506     } catch (...) {
102507       {
102508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102509       };
102510     }
102511   }
102512 }
102513
102514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
102515   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102516
102517   arg1 = (Dali::Toolkit::WebView *)jarg1;
102518   {
102519     try {
102520       (arg1)->Suspend();
102521     } catch (std::out_of_range& e) {
102522       {
102523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102524       };
102525     } catch (std::exception& e) {
102526       {
102527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102528       };
102529     } catch (Dali::DaliException e) {
102530       {
102531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102532       };
102533     } catch (...) {
102534       {
102535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102536       };
102537     }
102538   }
102539 }
102540
102541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
102542   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102543
102544   arg1 = (Dali::Toolkit::WebView *)jarg1;
102545   {
102546     try {
102547       (arg1)->Resume();
102548     } catch (std::out_of_range& e) {
102549       {
102550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102551       };
102552     } catch (std::exception& e) {
102553       {
102554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102555       };
102556     } catch (Dali::DaliException e) {
102557       {
102558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102559       };
102560     } catch (...) {
102561       {
102562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102563       };
102564     }
102565   }
102566 }
102567
102568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
102569   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102570
102571   arg1 = (Dali::Toolkit::WebView *)jarg1;
102572   {
102573     try {
102574       (arg1)->GoBack();
102575     } catch (std::out_of_range& e) {
102576       {
102577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102578       };
102579     } catch (std::exception& e) {
102580       {
102581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102582       };
102583     } catch (Dali::DaliException e) {
102584       {
102585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102586       };
102587     } catch (...) {
102588       {
102589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102590       };
102591     }
102592   }
102593 }
102594
102595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
102596   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102597
102598   arg1 = (Dali::Toolkit::WebView *)jarg1;
102599   {
102600     try {
102601       (arg1)->GoForward();
102602     } catch (std::out_of_range& e) {
102603       {
102604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102605       };
102606     } catch (std::exception& e) {
102607       {
102608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102609       };
102610     } catch (Dali::DaliException e) {
102611       {
102612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102613       };
102614     } catch (...) {
102615       {
102616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102617       };
102618     }
102619   }
102620 }
102621
102622 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
102623   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102624   bool ret;
102625
102626   arg1 = (Dali::Toolkit::WebView *)jarg1;
102627   {
102628     try {
102629       ret = (arg1)->CanGoBack();
102630     } catch (std::out_of_range& e) {
102631       {
102632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
102633       };
102634     } catch (std::exception& e) {
102635       {
102636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
102637       };
102638     } catch (Dali::DaliException e) {
102639       {
102640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
102641       };
102642     } catch (...) {
102643       {
102644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
102645       };
102646     }
102647   }
102648   return ret;
102649 }
102650
102651 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(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)->CanGoForward();
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 void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
102681   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102682   std::string *arg2;
102683
102684   arg1 = (Dali::Toolkit::WebView *)jarg1;
102685   if (!jarg2) {
102686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102687     return;
102688   }
102689   std::string jarg2_str = std::string(jarg2);
102690   arg2 = &jarg2_str;
102691
102692   {
102693     try {
102694       if (jarg3) {
102695         void (*handler)(char*) = (void (*)(char*)) jarg3;
102696         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
102697           handler(SWIG_csharp_string_callback(result.c_str()));
102698         });
102699       } else {
102700         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
102701       }
102702     } catch (std::out_of_range& e) {
102703       {
102704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102705       };
102706     } catch (std::exception& e) {
102707       {
102708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102709       };
102710     } catch (Dali::DaliException e) {
102711       {
102712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102713       };
102714     } catch (...) {
102715       {
102716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102717       };
102718     }
102719   }
102720 }
102721
102722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
102723 {
102724   if (!jarg2) {
102725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102726     return;
102727   }
102728
102729   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102730   std::string exposedObjectName = jarg2;
102731   void (*handler)(char*) = (void (*)(char*)) jarg3;
102732
102733   {
102734     try {
102735       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
102736         handler(SWIG_csharp_string_callback(message.c_str()));
102737       });
102738     } catch (std::out_of_range& e) {
102739       {
102740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102741       };
102742     } catch (std::exception& e) {
102743       {
102744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102745       };
102746     } catch (Dali::DaliException e) {
102747       {
102748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102749       };
102750     } catch (...) {
102751       {
102752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102753       };
102754     }
102755   }
102756 }
102757
102758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
102759   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102760
102761   arg1 = (Dali::Toolkit::WebView *)jarg1;
102762   {
102763     try {
102764       (arg1)->ClearHistory();
102765     } catch (std::out_of_range& e) {
102766       {
102767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102768       };
102769     } catch (std::exception& e) {
102770       {
102771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102772       };
102773     } catch (Dali::DaliException e) {
102774       {
102775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102776       };
102777     } catch (...) {
102778       {
102779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102780       };
102781     }
102782   }
102783 }
102784
102785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
102786   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102787
102788   arg1 = (Dali::Toolkit::WebView *)jarg1;
102789   {
102790     try {
102791       (arg1)->ClearCache();
102792     } catch (std::out_of_range& e) {
102793       {
102794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102795       };
102796     } catch (std::exception& e) {
102797       {
102798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102799       };
102800     } catch (Dali::DaliException e) {
102801       {
102802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102803       };
102804     } catch (...) {
102805       {
102806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102807       };
102808     }
102809   }
102810 }
102811
102812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
102813   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102814
102815   arg1 = (Dali::Toolkit::WebView *)jarg1;
102816   {
102817     try {
102818       (arg1)->ClearCookies();
102819     } catch (std::out_of_range& e) {
102820       {
102821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102822       };
102823     } catch (std::exception& e) {
102824       {
102825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102826       };
102827     } catch (Dali::DaliException e) {
102828       {
102829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102830       };
102831     } catch (...) {
102832       {
102833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102834       };
102835     }
102836   }
102837 }
102838
102839 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
102840     return (Dali::Toolkit::Control *)jarg1;
102841 }
102842
102843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
102844   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102845   SignalConverter::WebViewPageLoadSignal* result = NULL;
102846   {
102847     try {
102848       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
102849     } catch (std::out_of_range& e) {
102850       {
102851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102852       };
102853     } catch (std::exception& e) {
102854       {
102855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102856       };
102857     } catch (Dali::DaliException e) {
102858       {
102859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102860       };
102861     } catch (...) {
102862       {
102863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102864       };
102865     }
102866   }
102867   return (void*) result;
102868 }
102869
102870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
102871   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102872   SignalConverter::WebViewPageLoadSignal* result = NULL;
102873   {
102874     try {
102875       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
102876     } catch (std::out_of_range& e) {
102877       {
102878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102879       };
102880     } catch (std::exception& e) {
102881       {
102882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102883       };
102884     } catch (Dali::DaliException e) {
102885       {
102886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102887       };
102888     } catch (...) {
102889       {
102890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102891       };
102892     }
102893   }
102894   return (void*) result;
102895 }
102896
102897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
102898 {
102899   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102900   {
102901     try {
102902       delete object;
102903     } catch (std::out_of_range& e) {
102904       {
102905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102906       };
102907     } catch (std::exception& e) {
102908       {
102909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102910       };
102911     } catch (Dali::DaliException e) {
102912       {
102913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102914       };
102915     } catch (...) {
102916       {
102917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102918       };
102919     }
102920   }
102921 }
102922
102923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
102924 {
102925   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102926   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
102927   {
102928     try {
102929       proxy->Connect(callback);
102930     } catch (std::out_of_range& e) {
102931       {
102932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102933       };
102934     } catch (std::exception& e) {
102935       {
102936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102937       };
102938     } catch (Dali::DaliException e) {
102939       {
102940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102941       };
102942     } catch (...) {
102943       {
102944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102945       };
102946     }
102947   }
102948 }
102949
102950
102951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
102952   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102953   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
102954   {
102955     try {
102956       proxy->Disconnect(callback);
102957     } catch (std::out_of_range& e) {
102958       {
102959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102960       };
102961     } catch (std::exception& e) {
102962       {
102963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102964       };
102965     } catch (Dali::DaliException e) {
102966       {
102967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102968       };
102969     } catch (...) {
102970       {
102971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102972       };
102973     }
102974   }
102975 }
102976
102977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
102978   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102979   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
102980   {
102981     try {
102982       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
102983     } catch (std::out_of_range& e) {
102984       {
102985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102986       };
102987     } catch (std::exception& e) {
102988       {
102989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102990       };
102991     } catch (Dali::DaliException e) {
102992       {
102993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102994       };
102995     } catch (...) {
102996       {
102997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102998       };
102999     }
103000   }
103001   return (void*) result;
103002 }
103003
103004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
103005 {
103006   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103007   {
103008     try {
103009       delete object;
103010     } catch (std::out_of_range& e) {
103011       {
103012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103013       };
103014     } catch (std::exception& e) {
103015       {
103016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103017       };
103018     } catch (Dali::DaliException e) {
103019       {
103020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103021       };
103022     } catch (...) {
103023       {
103024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103025       };
103026     }
103027   }
103028 }
103029
103030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
103031 {
103032   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103033   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
103034   {
103035     try {
103036       proxy->Connect(callback);
103037     } catch (std::out_of_range& e) {
103038       {
103039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103040       };
103041     } catch (std::exception& e) {
103042       {
103043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103044       };
103045     } catch (Dali::DaliException e) {
103046       {
103047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103048       };
103049     } catch (...) {
103050       {
103051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103052       };
103053     }
103054   }
103055 }
103056
103057
103058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
103059   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103060   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
103061   {
103062     try {
103063       proxy->Disconnect(callback);
103064     } catch (std::out_of_range& e) {
103065       {
103066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103067       };
103068     } catch (std::exception& e) {
103069       {
103070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103071       };
103072     } catch (Dali::DaliException e) {
103073       {
103074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103075       };
103076     } catch (...) {
103077       {
103078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103079       };
103080     }
103081   }
103082 }
103083
103084 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
103085   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
103086   char * jresult = SWIG_csharp_string_callback((const char *)result);
103087   return jresult;
103088 }
103089
103090 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
103091   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
103092   return result;
103093 }
103094
103095
103096 struct NativeImageSourcePtrHandle
103097 {
103098   NativeImageSourcePtr Ptr;
103099 };
103100
103101 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
103102 {
103103   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
103104   return (NativeImageInterface*)(arg1);
103105 }
103106
103107 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
103108 {
103109   void* jresult;
103110   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
103111   {
103112     try {
103113       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
103114     }
103115     catch (std::out_of_range & e) {
103116       {
103117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103118       };
103119     }
103120     catch (std::exception & e) {
103121       {
103122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103123       };
103124     }
103125     catch (Dali::DaliException e) {
103126       {
103127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103128       };
103129     }
103130     catch (...) {
103131       {
103132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103133       };
103134     }
103135   }
103136   jresult = (void *)handle;
103137   return jresult;
103138 }
103139
103140 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
103141 {
103142   void* jresult;
103143   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
103144   jresult = (void*)( handle->Ptr.Get() );
103145   return jresult;
103146 }
103147
103148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
103149   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
103150   {
103151     try {
103152       delete arg1;
103153     }
103154     catch (std::out_of_range & e) {
103155       {
103156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
103157       };
103158     }
103159     catch (std::exception & e) {
103160       {
103161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
103162       };
103163     }
103164     catch (Dali::DaliException e) {
103165       {
103166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
103167       };
103168     }
103169     catch (...) {
103170       {
103171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
103172       };
103173     }
103174   }
103175 }
103176
103177 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
103178 {
103179   void* jresult;
103180   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
103181   uint16_t* arg2 = (uint16_t*)(jarg2);
103182   uint16_t* arg3 = (uint16_t*)(jarg3);
103183   uint16_t* arg4 = (uint16_t*)(jarg4);
103184   {
103185     try {
103186       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
103187     }
103188     catch (std::out_of_range & e) {
103189       {
103190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103191       };
103192     }
103193     catch (std::exception & e) {
103194       {
103195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103196       };
103197     }
103198     catch (Dali::DaliException e) {
103199       {
103200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103201       };
103202     }
103203     catch (...) {
103204       {
103205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103206       };
103207     }
103208   }
103209   return jresult;
103210 }
103211
103212 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
103213 {
103214   bool jresult;
103215   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
103216
103217   {
103218     try {
103219       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
103220     }
103221     catch (std::out_of_range & e) {
103222       {
103223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103224       };
103225     }
103226     catch (std::exception & e) {
103227       {
103228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103229       };
103230     }
103231     catch (Dali::DaliException e) {
103232       {
103233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103234       };
103235     }
103236     catch (...) {
103237       {
103238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103239       };
103240     }
103241   }
103242   return jresult;
103243 }
103244
103245
103246 #ifdef __cplusplus
103247 }
103248 #endif
103249